When I was in school umpteen years ago, I took a course about oddball programming languages. It was kind of like a survey course. We had to write simple programs in half a dozen weird languages. Lisp was one, I think Snobol may have been another. I remember I had a hard time coming to grips with Lisp. What I ended up doing when I was trying to write a program is - I would step through it mentally, paper and pencil. There were like two operators, one was CAN and the other was, I dunno, CANT, maybe? Doesn't matter, what did matter was how many arguments there were. If there was only one argument, they did one thing, if there was more than one, they did something else, so in my head, I treated these operators as if statements. By walking through all the possibilities I could see what was going to happen and what went wrong and fix the problem. Seemed like a lot of extra mental effort for not much gain. Just use a normal language that has if statements so you can see the possibilities.
I suppose if you had immersed yourself in the Lisp religion you might learn to think in terms of CAN and CANT, but I wasn't having it.
I Hacked This Amazon Router. What I Found Should be Illegal.
Low Level
I really enjoyed this video, not because I want to hack a router, but because this is exactly the kind of work I used to do when I worked iRMX support at Intel. It was like old home week. I haven't heard anybody talk nuts and bolts about computers for a long time.
At Intel I was dealing with people (customers) who had bought a bunch of boards, stuffed them into card cages, connected them up to who knows what kind of industrial machinery, written a mountain of code, and then called us when it didn't work. Most problems that came to me I was able to sort out with what I could find at my desk, but the acute cases meant working with a crusty old electrical engineer and setting up a system with some kind of electronic test equipment so we could watch electrical signals on lines on the board. There were in-circuit emulators, which were cool, but we never really needed to go there. Look at the code in the debugger, set breakpoints, let it run and watch the lines. From that we had to deduce what the problem was. Learned a lot about computers back then.
I came up with a way to factor numbers without dividing. I use a table and by chaining through the table I can factor any number. Problem is - for big numbers I need a really big table. The amount of memory the table would require would be equal to 100 times the number you want to factor, and that only works up to the quadrillions. But then I got to thinking that much of table is going to be repetitive, and you might be able to just record the differences from the base table and so generate any portion of the table you need. Going to run some experiments, see how they work out.
Gotta give this guy credit for knowing his limitations, his persistence, his unwillingness to just use an off-the-shelf computer, and finally building a machine that works, all just to keep himself entertained.
“Hello, world” from scratch on a 6502 — Part 1
Ben Eater
This is where I spent my 20 years working on computers. Now that I think about it, a couple of computers I worked on, the PDP-8 and the TI 990 Minicomputer, both had pushbuttons on the front panels that allowed you to enter data directly into memory using your fat little fingers, otherwise known as fat-fingering. You only did that a couple of times before you got your ducks in a row and started using terminals to write code.
This guy has a long way to go to write his "Hello, world!" program.
The Original Sin of Computing...that no one can fix
LaurieWired
Boy she talks fast, and long, but pretty clear. I suspect the basic idea for writing a Quin is to have a block of text that contains all the code in the program. The program writes this block out twice, once as code, and once as a block of text in the middle of the code, so the program actually contains two copies of this block of text.
My friend Elliot writes computer programs that displays colorful stuff on computer screens:
"This is creepy as heck, but I am having fun with it. This uses a difference filter that I have written from scratch using Windows Media Foundation. The filter was inspired by some sci fi that I read, which posited that dinosaurs could only see movement. When you stop moving, the image sort of fades away..."
Terry Davis (1969-2018) created Temple OS, a biblically themed computer operating system. A very smart guy, in the 1990s he developed some mental problems and we see where that led him. Lately I've been thinking I should have written my own OS instead of fighting all the problems that come with existing ones, but given Terry's story, maybe it's good that I didn't.
Okay, it's not really a self-driving system, it's an 'advanced driver assistance system'. I dunno, I kinda think they are just useful enough to be dangerous. If they do a good job of driving the car you are very likely to be lulled into complacency and then when something unexpected happens, are you going to be alert enough to react? Seems to me the only way to maintain constant alertness is to do your own driving.
Computers can be very reliable, certainly more reliable than people. But a system for driving a car needs to be able to avoid, or at last cope with, impending disasters. The question for most people is: are these systems going to better than a good driver? Being better than an average driver might be good enough for insurance companies, but everyone who thinks they are better than average (which is everyone) is going to want a system that is statistically better than good.
There are some poor drivers out there, and there are some people who don't like driving and for them these fancy gee-gaws might be useful. Can't imagine that anyone would not like driving. I mean, isn't that what makes us Americans?
Supported Device: a comma 3/3X, available at comma.ai/shop.
Software: The setup procedure for the comma 3/3X allows users to enter a URL for custom software. Use the URL openpilot.comma.ai to install the release version.
We run the latest openpilot in a testing closet containing 10 comma devices continuously replaying routes.
Licensing
openpilot is released under the MIT license. Some parts of the software are released under other licenses as specified.
Any user of this software shall indemnify and hold harmless Comma.ai, Inc. and its directors, officers, employees, agents, stockholders, affiliates, subcontractors and customers from and against all allegations, claims, actions, suits, demands, damages, liabilities, obligations, losses, settlements, judgments, costs and expenses (including without limitation attorneys’ fees and costs) which arise out of, relate to or result from any use of this software by user.
THIS IS ALPHA QUALITY SOFTWARE FOR RESEARCH PURPOSES ONLY. THIS IS NOT A PRODUCT. YOU ARE RESPONSIBLE FOR COMPLYING WITH LOCAL LAWS AND REGULATIONS. NO WARRANTY EXPRESSED OR IMPLIED.
User Data and comma Account
By default, openpilot uploads the driving data to our servers. You can also access your data through comma connect. We use your data to train better models and improve openpilot for everyone.
openpilot is open source software: the user is free to disable data collection if they wish to do so.
openpilot logs the road-facing cameras, CAN, GPS, IMU, magnetometer, thermal sensors, crashes, and operating system logs. The driver-facing camera is only logged if you explicitly opt-in in settings. The microphone is not recorded.
By using openpilot, you agree to our Privacy Policy. You understand that use of this software or its related services will generate certain types of user data, which may be logged and stored at the sole discretion of comma. By accepting this agreement, you grant an irrevocable, perpetual, worldwide right to comma for the use of this data.
I've been thinking about text editors, Aedit in particular. Aedit was like the first text editor I really got to know. This was back in the early 1980s and we were using Intel blue box development machines that the company was renting from Intel for the astronomical price of a thousand dollars a month, least ways that's the way I remember it.
I kept using Aedit when I went to work for Intel. I spent, I dunno, five or ten years using it. Then Windows came on the scene with their fancy schmantzy bullshit and I got to learn a whole new way way or ruining my life.
So here we are 30 years later and I am still pining for my lost Aedit text editor. Then I got to thinking that I should probably just write my own. I mean, how tough can it be? So now I'm thinking about this and I start thinking about different ways of storing text in memory. Do we do it by the line, or maybe strings, or just as one big block of text? This leads to the question of how do you handle the case where the text it too large to fit in memory? Kind of an unlikely scenario, I know, given the amount of memory modern computers have, but Aedit ran in like 64KB and could Handle any size file. Well, any size you could fit on a disk and our 8 inch hard disks were only 10MB. I do remember tackling files that were over one megabyte and Aedit did not complain. It might have gotten a little slow, but it handled the file just fine. So now I'm wondering how would I handle a multi-terabyte file. That is probably a ridiculous case, but if you are going to allow a program to handle large files, someone is going to push it to the limit, so you need to be prepared.
And then I thought: I wonder if maybe somebody else has already done this, and lo and behold, they have:
Using the source of Aedit shared on https://github.com/abiliojr/aedit.git, the code here is an attempt to port from PLM to C and to support newer operating systems.
So now I have another reason to get myself in gear and get a new Linux box and get away from this stinky Chromebox.
Ten or twenty years ago when I used to work at Stevens, I ran into a circuit that used a couple of ADCs (Analog to Digital Convertors). I was flummoxed when I started looking at it. ADCs are used to read the voltage of a signal and often that voltage is fluctuating at some frequency, so you want to taking readings often enough that you are getting a picture that reflects what is actually happening. If the signal is varies periodically with a frequency of, say 60Hz, like house current, and you take readings at the same frequency, your readings will all show the same voltage. It might be any value from zero to the maximum value. To get an accurate picture you need to take readings at some multiple of the signal frequency. Two, three or more times faster than the signal frequency.
When I look at the circuit and the ADC chips, I discover that the readings are transferred from the ADC to the CPU as serial data, that is, one bit at a time. Further, the two ADCs were daisy chained together, so the eight bits of data from one ADC were pumped out of one and into the other, and then pumped out of the second and into the CPU. This means that it took at least sixteen ticks of the serial clock to transfer the readings from the two ADCs to the CPU. This means that the serial data clock needs to be running 16 to 20 times faster than the frequency of the signal that you are trying to measure. This sounded nuts to me. Why would you want to handicap your measurement circuit with a 20x speed reduction?
Then I did the math and realized that the serial data clock was running at a frequency of something like 30 Mhz while the signal we were trying to measure was only around 1 megahertz.
This memory just popped into my head last night. Since it made such an impression on me I thought I would write it down.
The red arc describes the upper side of the hull, the blue follows the lower side. The straight green, red and black straight lines are radii for the upper arc. The length of the spindle is 70 meters and the diameter at the center is 8 meters.
I was reading about the Nautilus submarine from Jules Verne's 20,000 leagues under the sea. Seems the submarine in the novel was shaped like a spindle, not at all like the one in the movie. My question is: how do you compute the volume of a spindle? There might be a formula out there somewhere, but I have not found it. So I thought I would try calculating it on my own. Last week I made up a spreadsheet to sum the volume of sequential slices.
I used the Pythagorean formula to generate a formula to compute the radius of the hull from the distance from the bow. That seemed to work fine. The next day I tried to check my work, but being short on sleep my head was full of cotton and I could not make sense of it. Now I think I understand what it's like for people who have a hard time with math. It was like part of my brain was not working. Anyway, I'm doing better today so I took another look at it.
I decided the spread sheet was too cumbersome, so I wrote a little computer program to compute the volume by cutting the spindle into slices, computing the volume of each slice and then adding them all together. The volume is in cubic meters. Ten slices gets you to the nearest meter and a thousand slices will get you to the nearest cubic centimeter. Beyond that any differences that show up might be due to the limits of double precision arithmetic.
The volume is in cubic meters. At one hundred slices we already have the volume to the nearest liter (one one-thousandth of a cubic meter). At one thousand slices we have the volume to down to one cubic centimeter (one milliliter). At ten million slices the last digit starts changing. I suspect we have reached the limit of what can be done with floating point math without taking a closer look at the equations. I'm not going to do that. The nearest cc is close enough for me.
Comma-fication
Big numbers without commas are hard to read, so I spent most of a day working out how to automatically place commas in the output. It made the program four times as long. In some versions of C you can use an apostrophe to tell printf to insert commas, but it wasn't available with the online compiler I used, so I wrote my own routines. And because I wasn't sure if it was working correctly, I wrote another one to verify the first.
I also added some rudimentary command line parsing so you can change the length, beam and number of slices without having to modify the code.
Nematodes have successfully adapted to nearly every ecosystem: from marine (salt) to fresh water, soils, from the polar regions to the tropics, as well as the highest to the lowest of elevations. They are ubiquitous in freshwater, marine, and terrestrial environments, where they often outnumber other animals in both individual and species counts, and are found in locations as diverse as mountains, deserts, and oceanic trenches. They are found in every part of the Earth's lithosphere, even at great depths below the surface of the Earth. They represent 90% of all animals on the ocean floor.
Story I heard was that they are so pervasive that if you took away all grass and trees and dirt but left the nematodes, everything would still look the same.
A connectome is a map of the brain's neural connections, also known as the brain's wiring diagram. It's made up of neurons that communicate through synapses, and each connection is made up of the presynaptic axon, the postsynaptic dendrites, and synapses between the neurons. Connectomes can be represented in graph or matrix form, and are used to analyze network organization.
NSO Group Technologies (NSO standing for Niv, Shalev and Omri, the names of the company's founders) is an Israeli cyber-intelligence firm primarily known for its proprietary spyware Pegasus, which is capable of remote zero-click surveillance of smartphones. It employed almost 500 people as of 2017.
NSO claims that it provides authorized governments with technology that helps them combat terror and crime. The company says that it deals with government clients only. Pegasus spyware is classified as a weapon by Israel and any export of the technology must be approved by the government.
According to several reports, NSO Group spyware has been used to target human rights activists and journalists in various countries, was used for state espionage against Pakistan, for warrantless domestic surveillance of Israeli citizens by Israeli police, and played a role in the murder of Saudi dissident Jamal Khashoggi by agents of the Saudi government.
In 2019, instant messaging company WhatsApp and its parent company Meta Platforms (then known as Facebook) sued NSO under the United States Computer Fraud and Abuse Act. In 2021, Apple filed a lawsuit against NSO in the U.S., and the US included NSO Group in its Entity List for acting against U.S. national security and foreign policy interests, effectively banning U.S. companies from supplying NSO.
When you Accidentally Compromise every CPU on Earth
Daniel Boctor
What he's talking about here is virtual lockpicking. There is something about locks that attracts a certain kind of person, a person who says 'Hah! You think you can keep me out? I will show you. Nothing can keep me out. Your security is worthless!' The Lock Picking Lawyer comes to mind. They are people who like solving puzzles. I like solving puzzles, but I only enjoy working on puzzles that I can solve in short order, like five minutes. Oh, I might spend a couple of hours on a jigsaw puzzle, but that's about my limit.
I sometimes think about wading into computer security, but that is going to take a lot more time, and where's the payoff? Even if you manage to break into a computer system, are you even going to find anything valuable? And valuable to who? And would you trust anyone who sanctions breaking into someone else's computer system? Psychopaths could find ways to entice computer security experts into breaking into other's computers with enticements and challenges, but do you really want to be doing business with psychopaths? Get paid in cash and never tell them where you are. They'll sell you down the river in a heartbeat.
The crux of Spectre is that it can 'trick' the CPU into accessing memory belonging to another process because it is only a 'speculative' access. Another interesting bit is that apparently you can time how long it takes to access a single memory location. A simple way would be by setting a timer before reading memory and reading the timer afterwards, but that would mean locking out interrupts for the duration, and I'm pretty sure nobody but the operating system gets to lockout interrupts. Given that CPUs have gotten a zillion times more complex since I last fiddled with interrupts, there's probably several other ways to do it.
It's not like I don't have enough to do, but I had to start playing with ncurses, a computer programming library that enables doing crude, text based graphics in a terminal window. I did something and now my cursor keys are behaving erratically and capital-h and control-h don't work. I am going to try and find a solution, but I suspect I will have to reboot to clear things up. I am reluctant to do that because I've had a stupid recursion demo running in another terminal window for about a week and it would be a shame to shut it down when it is so close to finishing. Yeah, right, it's probably going to take a couple of months to finish and we'll probably have a power failure before then.
9,223,372,036,854,775,807 = nine quintillion two hundred twenty three quadrillion three hundred seventy two trillion thirty six billion eight hundred fifty four million seven hundred seventy five thousand eight hundred seven
I've been spending a little time on quora lately, looking at computer programming questions mostly. Most of them are pretty wretched, people who have no idea what they are talking about asking questions that don't make any sense, or people asking how to write elementary programs, questions that you might find in the homework for a programming class, but every once in a while you get a real question that prompts me to reply.
I used to think the requests for elementary programs were from people looking for someone to do their homework for them, but then I realized that a lot of these questions were being answered. Now I wonder if they aren't being churned out by someone looking for points from the quora masters and the people who are answering them are just looking for a little something to occupy their mind. Some people do crosswords, some people do jigsaw puzzles, some people play video games and some people write elementary computer programs.
I write basically useless computer programs, but I have a higher purpose, like I am trying to learn something, or I am trying to explain something, or I just want to see if I can do it. I post them on github, though I don't know if anyone has every bothered to look at them. They're up there if you want to take a look. They are all written in C.
That's a lot of numbers. How can I be sure it is translating them correctly? Well, you write a test program to compute the numeric value from the English words. That one was a little more difficult because I was getting tired and making stupid mistakes, but I got it done. For as much testing as I have done everything seems to check out. I could set it up to test all of the numbers, but I am not sure we have enough time. It took 3.4 seconds to test 1,000,000 (one million) numbers. At that rate it would take an hour to test a billion numbers, a week to test a trillion numbers, 25 years to test a quadrillion numbers, 2,500 years to test a quintillion numbers and 25,000 years to test nine quintillion numbers, and double that if we want to include the negative numbers. Ain't nobody got time for that.
You know, someone has probably already written a library function to do this, but I'd have to Google it, and then I'd have to figure out how to a get a hold of it, and read the instructions on how to use it, and that shit isn't any fun, unless it's something I need in order to do what I want to do. Writing it myself was actually fun.
Playing with a little bit of algebra and trying to write a program to solve a particular problem. I need to factor a number, which means I need a list of prime numbers, so how much space do I need given a number of certain size? x/9 (blue) approximates x/log(x) well enough for my purposes for values of x under a billion.
I came across a different version of Numbrix called Jadium. Well, not really, I stumbled on a page with a single static example (above). Numbrix is a fairly simple game, you just need to fill in all the 9 x 9 square with the numbers from 1 to 81 in sequence. It shows up in the Sunday newspaper supplement Parade, if you still get the Sunday paper. It's usually pretty easy, but change up the starting configuration just a bit and it can quickly become more difficult. Jadium is supposed to be more difficult and given that it has only a few numbers posted to start, I can see that it could be. But no on-line version, and just this one image, so I'm wondering if it is even possible to solve it.
How-some-ever, I wrote a program a while back to solve Numbrix puzzles and since this one conforms to the same rules as Numbrix, it should be able to solve it. So I tried it out.
Just for a baseline, I tried it with a completely empty field.
+----+----+----+----+----+----+----+----+----+
| 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 |
+----+----+----+----+----+----+----+----+----+
| 18 | 17 | 16 | 15 | 14 | 13 | 12 | 11 | 10 |
+----+----+----+----+----+----+----+----+----+
| 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 |
+----+----+----+----+----+----+----+----+----+
| 36 | 35 | 34 | 33 | 32 | 31 | 30 | 29 | 28 |
+----+----+----+----+----+----+----+----+----+
| 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 |
+----+----+----+----+----+----+----+----+----+
| 54 | 53 | 52 | 51 | 50 | 49 | 48 | 47 | 46 |
+----+----+----+----+----+----+----+----+----+
| 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 |
+----+----+----+----+----+----+----+----+----+
| 72 | 71 | 70 | 69 | 68 | 67 | 66 | 65 | 64 |
+----+----+----+----+----+----+----+----+----+
| 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 |
+----+----+----+----+----+----+----+----+----+
Number of calls to tracking procedure: 190
No problem, filled in the field very quickly. Next I tried it with the Jadium example.
+----+----+----+----+----+----+----+----+----+
| 57 | 56 | 55 | 54 | 53 | 52 | 51 | 50 | 49 |
+----+----+----+----+----+----+----+----+----+
| 58 | 59 | 60 | 61 | 64 | 65 | 46 | 47 | 48 |
+----+----+----+----+----+----+----+----+----+
| 3 | 2 | 1 | 62 | 63 | 66 | 45 | 44 | 43 |
+----+----+----+----+----+----+----+----+----+
| 4 | 73 | 72 | 71 | 70 | 67 | 24 | 25 | 42 |
+----+----+----+----+----+----+----+----+----+
| 5 | 74 | 77 | 78 | 69 | 68 | 23 | 26 | 41 |
+----+----+----+----+----+----+----+----+----+
| 6 | 75 | 76 | 79 | 20 | 21 | 22 | 27 | 40 |
+----+----+----+----+----+----+----+----+----+
| 7 | 8 | 9 | 80 | 19 | 32 | 31 | 28 | 39 |
+----+----+----+----+----+----+----+----+----+
| 12 | 11 | 10 | 81 | 18 | 33 | 30 | 29 | 38 |
+----+----+----+----+----+----+----+----+----+
| 13 | 14 | 15 | 16 | 17 | 34 | 35 | 36 | 37 |
+----+----+----+----+----+----+----+----+----+
Number of calls to tracking procedure: 323,522,476
This one took a while, several seconds in fact, long enough to make me wonder if it had gotten hung up. But no, it just took a while.
