Getting Screwed Over

Seems like the only thing I talk about on this blog is hardware, so why quit now? Recently I ordered a Samsung Chromebook Plus V2. It’s not that great of a computer, but it has a 1980×1200 inch screen, a touch panel with pen, can fold back into a tablet, with 4GB RAM and 64GB SSD. So it probably has short comings, but for around $350, it’s decent, and something I can play around with.

The problem is what actually arrived is a Samsung Chromebook 3. With a 1376×768 screen, 2GB of RAM and 16GB SSD. Which really sucks because now I need to ship it back to the States in order to get a refund. The box that they sent it to me in is also stupidly huge. So I need to get a new box, get some bubble wrap, and then print all of the labels and take it to the post office. Today I need to print the labels. And tomorrow I need to stop by the post office to get a box, and maybe bubble wrap. So I can take that stuff home and pack it.

Really sucks to have to try and run around to do stuff at the post office outside of work hours. What I’m really annoyed with is how crappy the Chromebook is that they sent me. I wouldn’t mind if I had gotten the wrong thing that was at least half-decent.

Making Use Of Raspberry Pi’s

Right now I have a bunch of Pi’s sitting around my house. And I keep thinking that I can use them for different small projects, but in reality it seems like I get busy with work and family, and then I never get around to actually messing around with the Pi’s. And right now something I do pretty poorly is managing my VPS’s. I have a bunch of random things scattered around a bunch of VPS’s. And now that I have fiber optic internet, it seems like I should try and make better use of local resources on my network.

There is the option of trying to move everything to free hosting on Github. I tried using Gatsby, but it seemed like a lot of work to try and convert a site to use it. Mainly it seemed like a bad investment. Something like NextJS would allow me to set up projects as well as static sites, so going forward that seems like the right tool to use. Converting what I have doesn’t seem like the best use of my resources at the moment.

So what kind of things will I be looking at?

– Moving did.shellshop.lol
– Probably moving shellshop.lol in general
– Moving this blog
– Setting up a NextCloud instance
– Setting up a network share

The main crux is how I want to manage my DNS, and hosting. For the DNS, the most direct option would be to set up my Raspberry Pi Zero W to be a dedicated Pi-hole instance. I tried to use it for taking notes, the problem is that there doesn’t seem to be reliable way of running Nodejs on the Pi Zero, so otherwise it’s only been holding static contents. If the Raspberry Pi Zero W was able to run Nodejs, it seems like it would be a great little development server. This is why I ordered a Raspberry Pi Zero 2W, so we’ll shuffle things around and see how that works.

Mostly I think we’ll be running into https problems around hosting. I have two options. The first is to use a VPS to reserve a static IP and then forward all of the traffic to the Raspberry Pi, or the second option is to use a dynamic DNS. And since I’m trying to reduce the number of VPS’s i have, the dynamic DNS approach seems to be more in the spirit of what I’m going for.

Edit:

It looks like in terms of practical application. I’m getting a 504 error timeout when I try to access my local network remotely. And the Raspberry Pi’s connected to my LAN keep dying for some reason. I think the easier option might be to simply to rent a cheap VPS that will act as an NGINX server to validate Let’s Encrypt, and then use a VPN to reverse proxy the request back to my local network. In general I’m not in too much hurry to do this. I might start by making a list

Playing around with more hardware

I finally got a functional home office cobbled together. I have a decent screen, a decent computer, and a key board and mouse. For the screen I have a 3440×1440 wide screen monitor. I’m generally on the fence about having an ultrawide versus a normal 4k monitor. In terms of width, it’s basically the same number of pixels, the main difference is how tall the monitor is.

My main thinking was that for coding it makes more sense to have a wider monitor, since I don’t need to use the vertical space as much. So I would prefer for the extra space to simply not exist instead of being “too tall”. The counter point to that is that I find myself branching off into more work flows like sketching or editing video where the vertical space actually helps. So I think i might move over to using one or more 4k monitors the next time I upgrade my computer.

In terms of the computer it’s a Thinkcentre Tiny with a Ryzen 2200GE. Since I generally use a terminal and watch youtube, it’s probably more than enough to run what I need it to. The main downside is the single channel memory which mostly has an impact on games. If it can run Resident Evil 0 or Resident Evil 4, i should be pretty happy. I don’t often have time to game, so I’m mostly generally interested in if the game will hypothetically run or not more than actually taking the time to play it. My actually gaming is focused on PSX or PSP games that can literally run on a toaster at this point.

For the keyboard, it never seems like I can find an “ideal” keyboard. I like tenless keyboards, but when I try mechanical keyboards they can be too loud and clacky. I tried the quiet mechanical keyboards and they turned out mushy. I like chiclet style keyboards, so a tenless chiclet style keyboard would be pretty awesome. In general I don’t seem to have any problems with membrane keyboards as long as they have a bit of travel and are quiet. The SK-8827 lenovo keyboard that came with the Thinkcentre I bought is pretty nice. It if didn’t have the number pad, it would actually be pretty damn perfect. But in general it seems hard to find the right keyboard with the right amount of weight, key travel, noise, and key layout. Cheap options are often mushy and poorly made, expensive options are pretty punishing if they don’t pan out.

For mouse, for now at least i have a wireless quiet mouse. Since I don’t use a mouse too often, it’s not that big of a deal. Kind of tempted to ditching a mouse for a wacom tablet that doubles as a trackpad. But I probably don’t draw enough for that to be worth it, so a quiet, cheap, wireless mouse is fine.

Now that I have a working desk set up, I’m thinking of how this affects my other devices. I have two laptops, one with windows, and the other with Linux. For the one with Windows I keep it around to be on the safe side. It mostly sits there collecting dust, so something fanless, and thin and light would make more sense. For Linux I like having a thin-client for coding, so I would prefer to have something thin and light with a long battery life. Really hoping to see more ARM computers in the laptop space, I think that would be really compelling for both a lite windows computer that has office, a web browser, and a few programs. And a lite linux computer with i3wm / sway for writing code.

I think I would be needlessly wasting money for buying anything currently on the market. Really hoping to see some M1 macbook clones trying to copy what Apple has done, so I’ll try to wait and watch things pan out. I would love to have a laptop powered by a Raspberry Pi computer module with different replacable parts. But again, for now I’ll leave my laptops alone as they work well enough for now.

Also a note is that now that I have a linux desktop for my main computer, I can probably take my Raspberry Pi 4 and play around with it. I would like to try installing i3wm / Sway on the Raspberry Pi and being able to play around with a slim desktop environment. Not sure if I want to go the distance and buy a case with a beefy cooling fan, but I have a sata-SSD, so I’ll probably clear that off and make that available to the Raspberry Pi to play around with it.

Planning out the next two weeks

So right now I think I might actually gotten a job, or at least an offer. So since we’re in September, I’m going to be planning out the next two weeks to try and invest my time correctly. In terms of preparation I want to get my home office in order. Quick list for that would be:

1. A computer Screen
2. A computer chair
3. 5G internet
4. Computer

For the computer, I went ahead and ordered a think centre tiny, since that should be more than enough to run a terminal, browser and play a few games. I might need to upgrade the RAM and hard drive. The Ram only has 8GB, so I could bump that up to 16GB, or possibly 32GB depending on how expensive ram is. Probably 16GB makes the most sense if I can pop another RAM stick in there. For the hard drive, I’m really tempted to drop in 1 or 2 TB to have enough room. In terms of an operating system, I’m tempted to use Manjaro, but I might give Debian Bullseye a try first to see if that will work for what I need it. In terms of programs, all I need is Blender, Visual Studio Code, Firefox and Steam.

For the chair and screen, i can order those from Amazon. For the 5G, i need to upgrade my contract to be able to do that. So I might try logging into my account to see if I can upgrade that. Another problem point is my Nexus 5x battery died and I have to keep it plugged into power. So I might swap that out for a Google pixel and install Lineage OS on it. Or maybe if I’m only Japan for another year, I can skip on getting a new number entirely and set up a 050 number with my data plan.

In terms of projects and things to work on in the next two weeks. I have two priorities. The first is learning redux, and the second is logging in with json web tokens. I also want to get modoki.io set up, so i have some context to contrast working with did’s against. And then I also want to try logging with a public key / private key pair. And also I probably shouldn’t forget to go ahead with the paperwork to make sure everything is fine at my new job.

Monthly Challenges

One issue that I run into with programming, is that I always feel busy. I always feel like there’s something that needs to be done and I don’t have enough time to do it. And I’m always on the computer doing something. The problem is that when I finish that something or move on to the next thing, I can never remember what it was that I was doing, or what felt important at the time. It feels like such a huge waste of time, that I generally would prefer to be reverse engineering old games, but instead I’m “busy” doing something else. And if I can’t justify what that something was, then why wasn’t I investing it in reverse engineering games?

My plan to approach this is to focus on monthly challenges. The idea is that each month will be dedicated to a specific topic. and I can justify why I’m focusing on that specific topic. Define how far I want to get. And why I’m working on it over other random side projects. And then be able to track what I was doing for each month, so I don’t forget it as soon as its done.

Pre-July 2021 Before I broke my challenges into focus for a clear month, I started Whitmir.io, with the intention of making a portfolio piece to get into Freelance. I ran into several challenges with what I expected to be a straightforward side-project. The main issue that I ran into was the rich text editor. The design behind the project was to make a simple blog editor, where a user could create simple documents and then compile them into a book which could be exported in some e-book format.

The issue I had with the rich text editors is that I wanted to have more control of the design and it didn’t fit with how the different libraries I used were structured. And I ended up spending about two weeks going through different options before I reached the end of the month and decided that I had to move on.

In terms of what I learned from this project, I got some hands-on exposure to OAuth and Cors. The idea was to host a strictly static page that could be hosted on Github for free, and then users could login with a Google id, and then documented would be written to and from their Google drive account, to test out the idea of a “server-less” application. Overall that aspect of the application seems to work out. I think I would keep settings for the application, and document for the application in two separate folders. One for the meta data, and the other for documents.

Another option would be if hackmd.io releases an API to interact directly with that. I think a markdown editor might make a lot more sense than a rich text editor in that it makes the format a lot easier to work with. Something that I wasn’t sure about was how to manage the preview for a markdown editor. I think if the screen is big enough to offer a split screen. Otherwise it might be a good idea to split writing text with a button to switch to preview mode.

I think in retrospect that if I approached this again, I would split it up into a few more smaller parts. Make a page that only interacts with Google drive to build a book and pages. Make a page that only interests with Google Drive meta data. Make several different pages and test different options for editors and then have the ability to design around the editors. And then from there I would go back to the drawing board and implement the design. In general through it looks like hackmd.io does a pretty good job of being and editor, and also has the option to export to odf. So the priority for coming back to work on this side-project is quite low.

July 2021 – This was my first “official” monthly challenge. I spent a month to use Shellshop v2 as a way to learn react and TypeScript. And also took the opportunity to use Golang on the back end. What I learned from this is I should be using NextJs for routing and having the option to create and API on the back end. And learned I should be using redux for the model.

August 2021 – Originally my plan for this month was to make an updated version of the DashGL web page using Gatsby. This was changed when I applied for a company. And my homework became the subject of my monthly challenge. The challenge was to get familiar with did’s by creating a flow where a did is created, it’s verified by a third party. And then another party check the validity of the verification.

Making a new Blog and Backups

I think I’ll be making a new blog which will take the place of dashgl.com. I think that using GatsbyJs is going to be the best option for creating static content that can be hosted using Gitlab. And then I can set up a Raspberry Pi or machine that can continuously rebuild and push the blog to the web for any updates.

For a blog feed I think i’ll be using Hackmd.io. Which should make it easier to focus on content. I don’t know what it is about WordPress, but I find it very hard to write about actual content. Most of the time it’s off-topic side notes or musings that get posted here. So I think that having an offsite tool that I don’t need to manage should make it easier to focus on content.

I also need to back up my megaman legends threads. I’ll put a list to back up here:

mml1
https://mmls.proboards.com/thread/6217/list-megaman-legends-tools
https://mmls.proboards.com/thread/5884/megaman-legends-pc-modding
https://mmls.proboards.com/thread/6198/psx-megaman-legends-research-thread
https://mmls.proboards.com/thread/6173/file-animation-viewer-exporter-support
https://mmls.proboards.com/thread/6171/static-gltf-model-exports

mml2
https://mmls.proboards.com/thread/6248/megaman-legends-research-thread-psp
https://mmls.proboards.com/thread/6182/megaman-legends-format-analysis-thread

TypeScript Approach

After writing a long rant about TypeScript yesterday, it gave me the ability to rethink my approach. Basically my thinking is that TypeScript will help with react by being able to define strict values to manage state. My biggest issues with TyepScript and React is the syntax needed to create the classes, but looking online, it seems that most of the content was focused on using React with functions in TypeScript. That way I only need to declare interfaces for the structs for the properties being passed into a component, and not much else.

This generally means that I’ll need to learn how the useState function works, which means I’ll need to get more familiar with React. But it seems this approach is simpler as it allows me to pick my battles and not get too heavily involved in quirky syntax games, and be able to focus on making content instead of pulling out my hair.

In terms of mitigation, I should probably switch to golang. As it’s like writing C with a crayon. But more importantly it has bindings for GTK, and Vulkan. So it seems supported on the Linux desktop side of things. It can write a fast strongly typed server, and it can can be compiled to web ASM. I looked at the JS compiled, and I was a little disappointed it doesn’t produced typed arrays. So I think that client web will still be React + Typescript.

So my focus for TypeScript should probably be focused on Express + TypeScript and React + TypeScript and basically think of it as the new syntax required to work with these, as in all likelyhood it’s a syntax that will be required more and more in web development.

Thoughts on React and Typescript

After making some initial effort to learn React and Typescript, I’ll write my thoughts here.

React

I’ve only been using React for about a week now, but instantly I’m a huge fan and I can see the benefits of it. It allows you to break down different parts of the page into individual components. And allows you to write rules with JSX syntax instead of having to write document.createElement over and over again.

This makes it easier to make changes, and easier to focus on individual aspects of the code. And it makes it easier to import components from npm. In addition the create-react-app also sets up webpack which makes it easier to include npm modules into the repository. And the template already includes placeholder for setting up a progressive web app.

So overall, I have a really good impression of React, I can see how it’s helpful. And I might even dare say, it’s the number one most required “framework” to use client-side. In terms of adjusting, I need to change my mind-set from traditional Javascript. Right now my workflow is making static html and css, splitting them off into modules in Javascript, grabbing the elements, adding event listeners, adding data in, and then at the very end adding render functions as needed.

With React a lot of the focus is on rendering. So I need to figure out how and when to fit data into the flow. But I think that will come as I get more familiar with the framework, and don’t have to think about it as much. Another point of improvement I need to make is including Bootstrap via npm, and then including it in the project in a way that makes sense. Which shouldn’t be too hard as there are probably blog posts and videos that I can reference.

TypeScript

TypeScript is one that I’ve having a harder time getting adjusted with. And fundamentally I have a problem with the premise that you define types and the compiler will check the types for stupid mistakes for you. I think I’ve used JavaScript long enough that my brain does a lot of that without thinking, and it’s generally simple enough to convert a string to a number, or a string to a date when you need to, as you generally need to do that anyways when getting a value from an input elements, doesn’t seem like it’s saving you a lot of work.

One aspect that probably soured my experience is rather than trying Typescript on its own, I went straight to trying to use TypeScript with React. And this is a really aggravating experience as it’s rarely my types I’m defining, I need to know what types React is defining behind the scenes. So the compiler yells at me for everything. Passing a attribute into a component, bad. Trying to declare a object as a member of the class, bad. And the syntax is less than intuitive.

import React from 'react';

interface AppMemory {
	app: React.Component,
	header: React.Component,
	gallery: React.Component,
	product: React.Component,
	checkout: React.Component
};

interface AppBridge {
	mem: AppMemory,
	register: (string, React.Component)=>void
};

const ReactBridge: AppBridge = {

	mem : {
		app : null,
		header : null,
		gallery : null,
		product : null,
		checkout : null
	},

	register : function(key: string, instance: React.Component) {

		console.log('Saving %s', key)
		console.log(this)
		//this.mem[key] = instance

	}
}

export default ReactBridge

Here I’m trying to throw in a quick hack, that will let me save instances from different components, and let me call functions on them if I need to. So I make an interface to store the memory, and each key is of type React.Component and that works.

And then the function, I try to define two arguments, the first that takes a string, and the second takes an instance of a React Component to save.

But the compiler doesn’t like this. I can use a React.Component in the attributes above, and it has no problems. But when I try to use it as an argument, I run into problems. This is probably a quick internet search away from an answer, but it goes to illustrate that while React’s syntax is new, it’s intuitive, it’s what you expect. In contrast, TypeScript’s syntax is frustrating because most of the time, I have no idea what it wants. And at least in terms of using TypeScript with react, editing every other line breaks something.

And all of this boils down to the benefits that TypeScript supposedly saves you headaches in production, by catching errors in development. But I still have problems with that, in that TypeScript generally boils down to a few basic types, strings, numbers, and dates. The thing is, generally the flow of Javascript is to get input from an input field, and throw it into a database. Or get a value from a database, and then render it on the screen. So generally data should be standardized by the JSON you throw to the backend, and get from the backend, and there shouldn’t be too many hops between them.

But the most annoying part I find about TypeScript is that, why doesn’t it provide more data types? JavaScript generally works fine because you’re working with a UI which is generally strings, dates, and a few numbers here and there. Strings and dates don’t need a lot of checking, it’s the numbers that Javascript plays fast and loose with. So if we’re taking Javascript from a loosely typed language to a compiled program that is going to yell at you for everything, why not add uint(8, 16, 32, 64, 128), int(8, 16, 32, 64, 128), float, double, decimal? So you can have more control over the numbers to be able to work with numbers directly in Javascript?

Something like:

uint32 a, b, c;
a = 10;
b = 4;
c = a + b;

Should compile down into:

const uint32 = new UInt32Array(3);
uint32[0] = 10;
uint32[1] = 4;
uint32[2] = uint32[0] + uint32[1];

Which seems like it would actually be a huge benefit in terms of being able to offer easy to read syntax for working with Javascript that is annoying to write. Because TypeScript is attempting to be a superset of Javascript, it means you have to append all of these extra gimmicks with semicolons after everything.

let age:number = 5

In this case, this is kind of an extremely simplified example as age is already inferred as a number. But you have both let which declares a variable, and number which specifies the type of variable. Why not just declare the number instead of let?

Number age = 5

In other words if you’re trying to take all of the ambiguity out of JavaScript and tell people not to use the “:any” type, because it DeFeAtS tHE PoInT Of TyPEScRipT, then why even have it in there? Just give me the option to make TypeSc ript to a completely hard typed language and stop spitting on my cup cake and calling it icing. Which brings me to the next part of my rant, that a lot of what TypeScript does can already be done in Javascript.

Like Enums. If you need to declare an Enum, you can declare a constant, and then add in key values to that constant, and then turn off the setter. Which is basically what TypeScript does internally anyways. If you need to sanitize some input you can sanitize input, or throw an error.

And my main complaint about TypeScript is that while TypeScript attempts to be a super set of Javascript, it doesn’t seem to be for JavaScript programmers. It seems to be for all of the other programmers who lost their jobs because the web programming took over the world, and now they complain that JavaScript doesn’t have tupples and enums instead of actually learning Javascript. Or it’s for front end coders who are too stupid to not know they shouldn’t be adding two strings together expecting the output to be an int.

So in summary, most of the benefits that TypeScript offers can be implemented or emulated to some degree in Javascript directly. The syntax is intuitive and adds in a ton of stupid fucking colons, and brackets every where. And if it’s going to yell at you for using playing fast and loose with vanilla Javascript, then it shouldn’t even give you the option.

And my last side rant about TypeScript is where you would use it. Because you can write JavaScript to be explict if you know what you’re doing. And React is the first priority for a client side library, so you pretty much need to use it with React if you’re going to use it on the client. And on the sever, if you really want to use a strongly typed language, you can use something like Golang. So in addition to not understanding what the benefits of TypeScript are, I don’t understand why you would want to use it in the first place. If you use React on the client side and Golang on the server side. Really seems like it’s for a bunch of chimps who sit in front of a keyboard, letting VS Code autocomplete everything for you.

I’ll keep making an attempt to try and learn it, but i keep having to try to hold my lunch down as I do.

https://github.com/typescript-cheatsheets/react

Searching for a Job

Next year, I plan on returning to the United States. I’ve given notice at my current job, that I plan on quitting and moving back. Which means I’m looking at dev jobs. And a huge trend I’m noticing is that everywhere requires React and Typescript. And I have really mixed feelings about working with these.

In terms of TypeScript, my first impression was “oh, so like int and float in Javascript?”. But looking at it, it seems a lot more basic than that. Basically it provides a few simple Javascript types like String and Number. And defines variables to be a specific Javascript type. And then it checks that these types aren’t getting mixed in the compiler, and then produces some very basic looking Javascript syntax. As a programmer I find it pretty confusing as with Javascript, if you want to force a specific type, it’s pretty easy to write a few checks for instanceOf or use === to do some quick sanity checks, and raise an error when needed. On the surface level TypeScript seems to solve a problem that anyone with a semi-working brain and a year of Javascript experience should be able to solve.

On the employeer side of things. I think it’s kind of different. If you have a team, I can see how TypeScript could be used as a basic sanity check on a codebase to make sure that stupid mistakes that occurs between team members. And it probably also serves as a level-distinction. It’s pretty hard to gauge how talented a Javascript programmer is, but if someone can program TypeScript, then they probably know at least some fundamentals. Also with WebPack becoming required to build any project, there’s probably no reason not to throw TypeScript in there as well. And lastly, for any scrubs using an IDE, TypeScript probably helps by underlining problems directly in the editor, and showing pop-ups of function arguments and documentation when needed. I switched from Notepad++ to Vim several years ago, so this last one is kinda “meh”.

With React I’m also kind of hesitant, as with my approach, I really don’t think react is needed. I’m not sure if that’s a boastful or otherwise stupid statement to make. But in my case when I approach UI, what I do is sketch it out on paper. And then I make an HTML mock up. And then I go through and create each state of the application, and then define where and when I want different classes to show or hide content. And then from there all i need to do is write small snippets of Javascript to manage the state of the application. In this way most of the application is static contents. And while that might have been a problem a few years ago, these days there doesn’t seem to be much down side to this approach. There are a few instances where I might need to render a list. But I can create the full list with document.createElement, and then replace a single DOM element with replaceChild. Which is from what I can gather what React does under the hood anyways.

My biggest issue with React is how it would massively force me to change how i structure my application. Because I only render a small amount of content, I have a pretty set way of managing all of the DOM references in my application. And specifically when creating lists or dynamic content, it’s a lot easier to use document.createElement to create a dom reference that you immediately have access to and can assign event listeners directly in the scope that you want. In the case of React, I see a lot of “onclick=doSomething()” in people’s code, which looks like something I would have written in my first year of Javascript. I looks ugly, and when I’m not being given the reference to the DOM object, it really messes with the way I want to structure my application.

So these are the issues I have with TypeScript and React. I think there is kind of a silver lining with this. And that is that writing applications like this with web pack might force me to write the client as a static client and then use Nginx as a reverse proxy to separate out the server-side API. In which case I should probably be using Golang or something like that. Previously I did a fullstack engineering challenge where one of the requirements was to use a library such as TypeScript or React, which I completely ignored. I might go back and use that same challenge or approach as a learning experience for using TypeScript and React in a sample project, just to be able to say I’ve done it.

So this was mostly a rant about technologies I’m reluctant to put the investment into, but need to in terms of finding a job. For web libraries that I’m interested on my own right now. Number one is definitely Jekyll. It looks like it can be used by Github and Gitlab to generate pages. So if I can use that to manage some basic pages for documentation or tutorials, it would be great to host most, if not all of my sites as static pages hosted on Github or Gitlab and not have to rent private servers. Private Servers are cheap, but it’s just easier to avoid not having to manage what I don’t need to manage. Assembly script is another. I’m not sure when or where I would need or use that. But it seems like it could be fun. Potentially it could be used for something like packing and unpacking dml model files to and from threejs. Or maybe I could use it to unpack Megaman Legends models. Not sure when or how I’d use it, but either way it seems interesting.

And last is Gatsby / Next.js. And yes, I know this is more React. But it seems like React done right. Next.js seems to have support for multiple languages. But I really like the approach of Gatsby, which is to do everything on the client side and only grab what’s needed via ajax. So there is definitely some fun to be had. I should probably get TypeScript and React out of the way first.

Edit: I was also thinking of Jeykll when I wrote this. I really like the idea of being able to create a static site on Github and then hosting the pages without having to rent a VPS. I think Gitlab has the option of Gatsby (among others) and Github seems to support Jeykll. If there’s an option that works on both, it definitely seems like that would be a worth-wise investment for being able to write documentation, or simply hosting easy blog-sites.

Priorities

Thin and Light

I’ve been using my Android tablet a lot. And it really shows how amazing ARM cpu’s are. My tablet battery lasts all day, the performance is more than adequate for everyday use. Really hoping that there is a Linux equivalent of the Apple M1 Macbook sometime soon. Right now the Pinebook pro comes close, but it’s lacking USB (as far as I know) and I would love to have the same 16:10 2560×1600 screen resolution.

PiBoy Advance

For DashGL, I think I want to focus my attention on a hypothetical device somewhere around a GBA, or PSP in terms of form factor. Directional pad, shoulder buttons, four face buttons, start / select / home. The only issue is how much attention is given to the analog stick. Screen resolution is probably somewhere around 480p. Basically, something like the Odroid-Go Advance.

In terms of software i should probably focus on either SDL2 or Godot. In terms of reverse engineering I think I want to focus mostly on DS and PSP.

NDS

– Legend of Zelda (Hour Glass / Spirit Tracks)
– Okami
– Final Fantasy (Echos of Time)
– Phantasy Star Zero
– Animal Crossing

PSP

– Phantasy Start Portable 2 Infinity
– Rockman Dash 2
– Power Stone
– Metal Gear Solid
– Tenchu Stealth