241–250 of 304 posts
Earlier quoted context omitted.
From a guy that was doing cool things with a computer at age 12 but instead of starting to workout at age 12, started at age 18. Any age is good to start working out but sooner is better.
What bizarre advice for a programming thread. And what are those five days for?
Excuse my portion of scepticism, it's not the fact that a "12 year old" built this, sure anyone can learn how to code and we can't know how much help this person got along the way. But it's rather the person's language when writing plain text, here in the comments for example. It doesn't feel adolescent but more grownup to me ... But maybe it's just me realising my own shortcommings as a 12 year old, as I only was pl…
> It doesn't feel adolescent but more grownup to me
Showing skepticism is also fine, our industry is not just nice code review and beautiful moments where people want to encourage you.
Liam, this is incredible ! I thought it might be useful for you to incrementally see how someone in industry would review or change this code, so here's a little code review via video: https://youtu.be/UkVOrcS--04 We very incrementally build up to the final code, which can be found here: https://gist.github.com/stevekrenzel/b490564bf1c7f98e232a6c8... Hope you find it helpful!
Instead of this: (rule & (1 You could just do: (rule >> i) & 1 Otherwise it was a good review! I'd probably also extract parts of this long line so it's not as cumbersome to read: return state.map((item, i) => rules[((state[i - 1] || 0) * 4) + (item * 2) + (state[i + 1] || 0)] ); to return state.map((item, i) => { const prevItem = state[i - 1] || 0; const nextItem = state[i + 1] || 0; return rules[(prevItem It also u…
For example, instead of:
var length = Math.sqrt((x * x) + (y * y));
var length = Math.sqrt((x * x) +
(y * y));
You can also use indentation and formatting to bring out and make obvious other two-dimensional patterns and regularities, especially with two-dimensional cellular automata and graphics code.
There are some examples of that technique in my 2D cellular automata machine code. (There's a lot of code, so don't be overwhelmed, since I've been working on that since around 1985 or so. So never give up and just stick to it! You don't need to understand the code, which is pretty esoteric, just notice the patterns.)
https://github.com/SimHacker/CAM6/blob/master/javascript/CAM...
// Load the right two columns of the 3x3 window.
n = cells[cellIndex - nextCol - nextRow]; ne = cells[cellIndex - nextRow];
c = cells[cellIndex - nextCol ]; e = cells[cellIndex ];
s = cells[cellIndex - nextCol + nextRow]; se = cells[cellIndex + nextRow];
// Scroll the 3x3 window to the right, scrolling the middle and right
// columns to the left, then scooping up three new cells from the right
// leading edge.
nw = n; n = ne; ne = cells[cellIndex + nextCol - nextRow];
w = c; c = e; e = cells[cellIndex + nextCol ];
sw = s; s = se; se = cells[cellIndex + nextCol + nextRow];
var sum8 =
(nw & 1) + (n & 1) + (ne & 1) +
(w & 1) + (e & 1) +
(sw & 1) + (s & 1) + (se & 1);
var tableIndex =
(((c >> plane) & 0x03) > plane) & 0x03) > plane) & 0x03) > plane) & 0x03) > plane) & 0x03) > 1 ) & 0x03) When the sub-expressions won't fit on one line, you can still use indentation to help the reader understand the spatial patterns:
error +=
(nw * kernelBytes[4 - kernelDown - kernelRight]) +
(n * kernelBytes[4 - kernelDown]) +
(ne * kernelBytes[4 - kernelDown + kernelRight]) +
(w * kernelBytes[4 - kernelRight]) +
(c * kernelBytes[4]) +
(e * kernelBytes[4 + kernelRight]) +
(sw * kernelBytes[4 + kernelDown - kernelRight]) +
(s * kernelBytes[4 + kernelDown]) +
(se * kernelBytes[4 + kernelDown + kernelRight]) +
frob;
The point is you want to vertically line up as many of the repeated letters and symbols in nice neat columns as possible, so that your eye can easily see which are the same, and the ones that aren't stand out obviously so you can ignore all the same things and focus on the differences. (Which are typically variations like +/-, sin/cos, x/y/z, -1/0/1, nw/n/ne/w/c/e/sw/s/se, and longer series of names and numbers. Whatever changes should stick out visually, and be lined up and grouped together so your eyes can scan over them!)
That not only helps other people understand your code, but it also helps you be sure that you wrote the right thing, what you actually meant, instead of making an easy to miss typo.
The difficulty of reading you own code, which is HARD even for professional programmers, is that you usually see what you MEANT to write, not what you actually wrote. That's why it's so important to get other people to read your code, and to read other people's code, like pair programming and code reviews, or even explaining it to a duck.
https://en.wikipedia.org/wiki/Rubber_duck_debugging
It takes a lot more effort and concentration to slow down and look at what's actually there, instead of what you want to be there. (That's true for many aspects of life...)
This is why HN is great.
Hey looks good :)! Just a few things you might not know about: Google String.prototype.padEnd. It’s built in to JS and should be able to replace your zero fill function. And instead of mutating the ruleSet array you should be able to use Array.prototype.map like this: const ruleSet = zeroFill(8, rules.toString(2)) .split('') .reverse() .map(item => parseInt(item, 10)); And you can clone arrays like this, instead of u…
Good tips if you want your code to fail randomly on older devices.
I guess I'm the only one here doubting that the combination of both this project and the language used in the comment replies is coming from a 12 year old. Take it as a compliment if it's legitimate.
Excuse my portion of scepticism, it's not the fact that a "12 year old" built this, sure anyone can learn how to code and we can't know how much help this person got along the way. But it's rather the person's language when writing plain text, here in the comments for example. It doesn't feel adolescent but more grownup to me ... But maybe it's just me realising my own shortcommings as a 12 year old, as I only was pl…
Liam, this is incredible ! I thought it might be useful for you to incrementally see how someone in industry would review or change this code, so here's a little code review via video: https://youtu.be/UkVOrcS--04 We very incrementally build up to the final code, which can be found here: https://gist.github.com/stevekrenzel/b490564bf1c7f98e232a6c8... Hope you find it helpful!
If you would start a channel where you review code of random public repos I would definitely subscribe. Well done.