todd8

Beware of Bacillus Cereus:

https://rightasrain.uwmedicine.org/body/food/leftover-rice-b...

I'm running the latest MacOS right now on a modest m4 Mini and it doesn't seem slow to me at all. I use Windows for gaming and Linux for several of my machines as well and I don't "feel" like MacOS is slow.

In any case, Chrome opens quickly on my Mac Mini, under a second when I launch it from clicking its icon in my task bar or from spotlight (which is my normal way of starting apps). When Chrome is idle with no windows, opening chrome seems even faster, almost instant.

This made me curious so I tried opening some Apple apps, and they appear to open about the same speed as Chrome.

Gui applications like Chrome or Keynote can be opened from a terminal command line using the open command so I tried timing this:

     $ time open /Applications/Google\ Chrome.app

which indicated that open was finished in under 0.05 seconds total. So this wasn't useful because it appears to be timing only part of the time involved with getting the first window up.

My first college girlfriend made me realize that I wasn't a fast thinker. In person our conversations didn't seem problematic to me, but on the phone she would respond too quickly to what I was saying. I wouldn't be able to get into listening mode in time to pick up on the beginning of her replies.

I suppose that different people just have different strengths and mine isn't quick repartee. Another unusual thing I've noticed is my inability to do my best thinking while music is playing. While working briefly at a company to help out some friends I was forced to hear music throughout my time working on location; it was terrible (for me). In school I always did my work in quiet settings.

I was a math major in college and music interfered with my math work more than other subjects. My theory is that math and music both rely on similar mental resources.

When I went to college, practically every student arrived with a slide rule. I bought mine when I was 14 years old. (I still have it, a Picket model N4-ES https://www.sliderule.ca/pickett.htm) We all learned to use them in High School and were expected to use them in our science and engineering classes.

There were mechanical adding machines (see for example https://www.burroughsinfo.com/portable-adders.html) but these were only practical for adding and subtracting and were heavy, bulky machines.

In engineering and the sciences, multiplication, division, trigonometric, and exponential functions were necessary. In the late 1960s, there were four alternatives for computing these operations: books containing printed tables of values (good for 5 or 6 decimal positions of precision at best), desktop scientific calculators like the Wang 360--expensive and not very common. I remember using one only once at MIT, "real" computers (running FORTRAN programs on punched cards or perhaps APL), or the lowly slide rule.

Slide rules were everywhere that scientists and engineers roamed in the late 1960's. They had only three parts: a pair of fixed rulers, a sliding ruler that slid between the two fixed rulers, and a cursor, which is a thin precise line in a window that could be used to line up the positions on the rulers. The rulers were inscribed not with evenly spaced marks (as measuring rulers are) but with marks starting at 1 (not zero) and going up to 10 spaced logarithmically.

Just as two yard sticks can be lined up to measure 5 feet, a rulers of a slide rule can be lined up to calculate the sum of two logarithms and adding logarithms can be used to perform multiplication.

A typical slide rule had dozens of scales, with spacing corresponding to the trig functions, exponentials, hyperbolic trig functions, logs of logs, etc. A slide rule could perform almost any function needed for basic science and engineering. There were two limitations; slide rules couldn't calculate sums or differences, and they were only accurate for perhaps 3 digits of precision.

The limitations on precision was due to the difficulty in reading the scale accurately; the scales were only around a foot long. To get another digit of precision you'd need a slide rule with fine marking ten times as long as our portable slide rules. The MIT museum had examples of just such devices. Typically, the scale would be marked on the outside of a cylinder in a helical fashion. Such devices could then get more than four digits of precision. See https://en.wikipedia.org/wiki/Fuller_calculator for an example of a cylindrical slide rule.

In 1971, some of my wealthier fellow students bought the Bomar Brain. It was the first portable electronic calculator that I ever saw and cost $240. In today's dollars that would be roughly $1900. All the device could do was add, subtract, multiply and divide. One would still need a slide rule for trig, square roots, logs, etc. A few years later, HP and others came out with hand held scientific calculators and I retired my slide rule, which now adorns my home office in its original leather case (with the belt loop to carry the slide rule at your fingertips).

Coincidently, I'm vacationing right now, and in the lobby there is a case containing an original Thatcher Calculator on display (https://commons.wikimedia.org/wiki/File:The_Thacher_Calculat...), another variation of the cylindrical slide rule and invented around 120 years ago.

Time for hexadecimal.

Rhino horns are not made of ivory.

Humans too can be committed to beliefs that are not true. I have friend that believes in and regularly consults her "clairvoyant". I wonder if our AI assistants in the future will be vulnerable to suspicions or popular fantasies about the world, people, or even other AIs they interact with.

It's an advertisement. Get over it. If you don't like waste, wash your plastic yogurt cups and reuse them as cereal bowls.

I personally didn't like Apple's "Crush" ad, and I was much more interested in the rest of the announcement. It's interesting how power efficient iPad's have become, and my guess is that these positive developments in efficiency far exceed the waste produced by obviously staged crushing of some tools used by artists.

How should we assess the value or cost to society of an advertisement? To start out with how much did the ad cost to produce and execute and what was its world wide impact? Was it really that wasteful? Apple's net annual income is around 100 Billion dollars per year. No matter how Apple produces an ad campaign it costs money that could have been used for kinder, gentler, more impactful endeavors, say more animal rescue shelters. But Apple wants to sell its products, and ads are important for that. Clearly, Apple's products bring great value to humans across the globe--they've voted so with their wallets. Does the crushed piano (likely involving special effects) really impact the world in any significant way or is it just the visuals that are so disturbing?

If it's actually just the seeing of a musical instrument being crushed that is so upsetting, then what are we to think of the countless instruments thrown in the trash after our elementary school kids give up on being guitarists, drummers, trombone players, or violinists. Why do we even let a 7 year old touch a violin if only 1 out of 100 ever play a level that isn't torture to listen to.

The reaction to this ad reflects a pernicious societal descent into relying on emotion instead of reason and accepting innumeracy instead of analysis.

There have been decades of work on file name completion put into Emacs, nothing I’ve seen comes close. Currently I’m using add on packages vertigo, orderless, marginalia, consult, embark, and corfu to handle completion. These packages all work together to produce a crazy good setup, but in the past I’ve used helm, ivy, icicle, and vanilla Emacs. Every one of these open source completion frameworks works great.

Of course, I’ll never get back the time spent fiddling with my 1600 line Emacs configuration file.

This isn’t obvious to me. It doesn’t have to simulate itself in real time. It may not be able to simulate itself simulating itself. There may be proof of this using a diagonalization proof.

Consider programs that are quines, programs are able to output the exact source code of the program. See [1].

And there are abstract computers that can produce any computable output. These are called Universal Turing Machines, see [2]. UTMs can be specified with a remarkably small number of internal states, see [3].

I’m not saying you are wrong, but computability is full of unintuitive results, and the answer may be more subtle than what is revealed by “just thinking about it”.

[1] https://en.m.wikipedia.org/wiki/Quine_(computing)

[2] https://en.m.wikipedia.org/wiki/Universal_Turing_machine

[3] https://en.m.wikipedia.org/wiki/Wolfram%27s_2-state_3-symbol...

Is there a reason for me to pick up Fleet if I already use JetBrains other IDEs?

I've taught hundreds of people programming. For one year, at my first real job, I was tasked with teaching the programmers within a big company Pascal. All of them were already professional programmers using Fortran, COBOL, or assembly language. The company had a commitment to modernize their software development practices and one facet of this was to introduce a more modern language--Pascal at that time (circa 1976).

I enjoyed that year and, for the most part, my "students" were easy to teach, and Pascal held up well. They were all programmers already, so I didn't have to go slow through the basics and introducing ideas like recursion (absent in Fortran, COBOL, and assembly language of the period) kept the classes new and interesting to the students.

Unfortunately, standard Pascal isn't really a good choice for a first programming language today, even though modern Pascals have removed many of early Pascal's limitations (packages, batteries included libraries, etc.)

So, how can we decide if a language is a viable first language? Employing the wisdom of crowds, here are the top 30 languages in the 2023 IEEE Spectrum rankings:

1-10: Python, Java, C++, C, Javascript, C#, SQL, Go, TypeScript, HTML.

11-20: R, Shell, PHP, Ruby, SAS, Swift, Dart, Rust, Kotlin, Matlab.

21-30: Scala, Assembly, Perl, Visual Basic, Objective-C, Lua, Fortran, Verilog, Groovy, Julia.

I contend that we should limit our choice of first-languages to some language in the top 30. This rules out many languages that I consider important, but we should stick with a language that is likely to benefit the student more than others as a first-language. That means not teaching Lisp or Racket or Ada or Ocaml or Prolog or even D for that matter as a first language.

To narrow our top 30 down to a handful of alternatives, I'm going to use my own subjective difficulty rating and remove C++ and Rust and Scala from the list because they will be too hard for beginners.

Furthermore, let's remove languages that aren't general purpose; this knocks out SQL, HTML, R, Shell, PHP, SAS, Matlab, Assembly, Visual Basic, and Verilog.

Some languages require more complex build or execution environments; I would remove Java, Dart, Kotlin, and Groovy from our list for this reason.

Finally, there are some languages that are not as easy to use outside of specific hardware or operating systems; I consider these languages C#, Swift and Objective-C to be ruled out.

For good measure, I'm removing Perl from the list (a bit too irregular) and Fortran (not widely used outside of some important areas).

Our condensed list now look like this:

Possible first languages: Python, JavaScript, Go, TypeScript, Ruby, and Julia.

To narrow it down even a bit further we can observe that one should learn JavaScript before learning Typescript. (Is this opinion shared by HN?)

Ruby and Python seem like close cousins with Ruby being a bit prettier and Python being much much more popular.

Julia is a bit specialized and a bit harder than the others so now we are left with just three: Python, JavaScript, and Go.

These must be the masses of the Mars rovers, the weights would be measured in newtons (or pounds in the USA) and would differ between mars and earth.

In grad school, many years ago, I would plug the drain and let the tub fill while I showered. I would pull the plug and let the tub drain once the water had cooled. This way my bathroom would warm up a bit. I suppose this might have saved a few cents.

BASIC was almost my first programming language. Ten years before anybody had a home computer (1967), I decided that I would write a program. I was just a kid and I came across a keypunch machine in a small room at my high school. After reading a book on FORTRAN I keypunched a program that was supposed to solve optimization problems over sets of linear equations in a number of unknowns constrained by a set of inequalities. The algorithm for doing this is known as the Simplex Method.

I gave the deck of cards to a friend and a couple of days later I got the fan-fold paper output that listed a bunch of syntax errors and nothing else. I just didn't understand programming very well.

BASIC is what got me on track. I found a book in my local public library on the relatively new language BASIC. It was easy to understand and I practiced writing out the solutions to simple problems with paper and pencil. I didn't have access to a BASIC system, but I learned enough that I could try FORTRAN again (this time on simpler problems). After a few attempts (with the two day turnaround) I was successful and programming became a hobby that eventually led to a career as a real computer scientist.

BASIC was just right. It was concrete enough for a novice to understand while being much more expressive than assembly language. I've never actually run any program that I wrote in BASIC, but I have written programs in scores of languages since and BASIC got me started.

Today, there are better choices for a first language: Python provides students with a lot of power right away, and my daughter learned Scheme as her first language and never had difficulties in later classes with recursion or functions as values.

I'm sure it was possible to punch the compiled executable as an option, but I was a student during most of my keypunching days so the cards would be read by a card reader the computer would compile the FORTRAN and then execute the program, reading input data from cards that were stacked behind the source code.

One summer, I worked at an engineering firm and had to run a program frequently on a set of input; it's possible that the executable I was loading into the card reader was already compiled and not the original FORTRAN source, but I don't remember for sure.

I lugged around my favorite boxes of programs on cards for years, I even had big, full sized tapes, see [1], containing more programs I had written.

[1] http://www.columbia.edu/cu/computinghistory/tapes.html

I still have fond memories of working on the 029 keypunch machines, the keys made such a satisfying sound. I also remember the rooms where thousands of chads from punching the cards collected and had a certain smell and the bright overhead lighting, the ample air conditioning, the raised floors, the background noise of the machines, the whirling tape drives; it was an experience I'll never forget.

I started programming around 1967-1968. In my high school, there was an old keypunch machine used for school administration purposes. I had a friend that was able to submit any program I keypunched to the school district's IBM computer; I never saw the computer but it's likely that it was something like an IBM 1130. My my friend would bring the output back a couple of days later; so fixing even one typo required a few days.

This old keypunch machine was a model 026, not the much nicer model 029 that was ubiquitous while I was in college. The 026 had a very basic keyboard, see [1], one could punch the columnar code for the upper case letters and numerals along with a handful of symbols: #@,%$./ and space. This isn't enough to even program in early FORTRAN, the language I was trying to use.

To type say an equals sign one had to use the multi-punch key that allowed punching a combination of the basic symbols that would properly encode the equals sign. It was slow going. One mistake and the card (corresponding to a line of code) was ruined and had to be redone.

I had just finished reading a book on solving linear programming problems, which come up often in operations research, using the simplex algorithm (I still have this book too). Naturally, I decided that that would be the first program I ever wrote. That definitely wasn't the best "hello world" program to try first. I wish I still had a listing of that program; it would be good for a few laughs.

The first working program I wrote printed out a table of sine and cosine values for angles from 0 to 90 degrees. The rest of my programs in high school were not much more sophisticated. I was just trying to learn it on my own as a hobby. I still own my book on Fortran that I bought with my newspaper route income back then, McCracken's book on Fortran IV [2].

A couple of years later I got to write more serious programs and used the IBM 029 keypunch machines that were a lot better. Programs got long enough (hundreds of lines!!) that card management became important. Sturdy cardboard boxes or even long metal drawers designed for holding the stacks of cards were the main tool for source code management.

In college, I was able to use IBM's data processing equipment for punching line numbers in columns 73-80 on each card (these columns are ignored by FORTRAN IV); this allowed dropped cards to be sorted back into order through a series of passes (one for each digit of line number) on IBM card sorting machines. This was my introduction to radix sorting, [3].

One complication when numbering cards was inserted new code between existing cards. Because of this, my initial punching of line numbers in columns 73-80 had to be done with gaps, usually I'd leave one or two zeros at the end of each card number. However, to get the auto numbering machine to do this required pulling out a large (1 foot square) plug board from the equipment and physically connecting jacks with switchboard like cables to make the equipment count by hundreds and punch in columns 73 through 80.

It was all quite primitive. But one did learn to review code carefully before submitting it for being run.

Grad school was better, I still frequently used FORTRAN punched on cards, but I was also able to use the mainframe in a timesharing environment where I used TECO as my text editor at a terminal, there must have been around twenty of these terminals connected to the CDC 6400, [4].

[1] http://www.columbia.edu/cu/computinghistory/026-keyboard.jpg

[2] https://archive.org/details/guidetofortraniv00mccr

[3] https://ibm-1401.info/KensSorter/type83-a.jpg

[4] http://www.bitsavers.org/pdf/cdc/cyber/cyber_70/kronos/60407...

I've wondered about this, but I don't trust myself to figure out the answer. Even though I have a background in math and I've done some cryptography related work, I know enough about the crypto space to know that I don't know enough to make my own decisions. The featured article by Filippo Valsorda makes a lot of sense.

On the other hand, if the NSA really could find backdoors into elliptic curves (perhaps with a great deal of work) they would be motivated to gaslight the rest of us about elliptic curves by creating article like TFA.

Thank you, the paper you cite makes clear claims: that the environmental (climate change, air pollution, etc.) impact should be priced into the cost of petroleum based fuels. The paper states that 92% of the subsidies to the oil & gas industry are because of the price of fuel doesn't reflect the societal costs related to pollution.

The interesting finding presented in the paper are:

[p. 9] "Underpricing of fossil fuels is still pervasive across countries and is often substantial, especially for coal."

[p. 9] 18% of these subsidies go to gasoline

[p. 9] "The power generation sector is the largest recipient of subsidies"

[p. 10] "By region East Asia and the Pacific accounts for 48 percent of total energy subsidies"

[p. 7] China and India together had 3.4 Million premature deaths due to air pollution in 2020 (The USA had 0.1 Million)

From an economic efficiency point of view, I can understand that prices are important, but wouldn't we have to take account of the benefits of using petroleum fuels too? Like allowing developing countries to feed their populations? They clearly can't do this with solar powered agriculture and solar powered shipping.

One of the interesting things that I discovered while working on some legal papers with a lawyer were that legal documents don't have copyright protection. Lawyers regularly copy and paste from other lawyers work. I suppose, that since legislators most often have backgrounds as lawyers, they legislated rules for themselves that are not the same as the rule the rest of us have to follow.

I am not a lawyer so I don't know that anything in the previous paragraph is true; it's just based on a recollection of something I was told once a long time ago.

How precisely? The taxes on profits from oil & gas related businesses are complex, but I honestly (as a computer scientist unrelated to oil & gas businesses) don't understand the claims that we subsidize oil & gas production. I know that the oil & gas industry is heavily taxed and there are numerous exemptions and complications to the tax regulations for that industry just as there are for other industries, but on balance it appears that oil & gas production pays billions to the US and state governments. See [1], for example.

[1] https://www.forbes.com/sites/drillinginfo/2016/02/22/debunki...

I understand that modern type systems can do anything (that can be computed) since they are Turing complete. So are Java generics and C++ templates and Lisp’s macro systems, but I don’t want these things.

I’ve written a number of Turing machine programs; yeah it’s impressive that an imaginary machine that is so simple can run any program that runs on any other computer, but it’s no fun writing code for a Turing machine. For the Theory of Computing studying Turing machines is important.

If I don’t want Turing complete type systems, what do I want? Well, first off, the bugs I find in my programs that are more troubling don’t seem to be stopped by strong type systems. What I want is to be able to declare assertions in my code. For example, I’d like to tell the compiler that the variable year must always satisfy (2000 < year < 3000) and that in a certain block of code that x and y are always within 0.5 of each other. I want the compiler to ensure that these invariants are satisfied by a combination of compile time and run time checks generated by the compiler.

The problem is that we can’t expect programmers to use Turing machine like type declarations, because the programmer must now program the type system without bugs to ensure that the types in the program carry enough information that higher level assertions can be made about the original program’s correctness.

TLDR, I want to work with higher level assertions about the code than that provided by complex types.