The kid? :)

I had to scroll back up to see what this reply was to, to get the full chuckle and yup, I was told frequently by my male parental unit that the top two reasons for having kids was chores and tax deductions. But there's a reason farm families leaned on the large side. The more hands you had helping the less hard things could be while never being easy

Software or hardware, the lock-down for dollars will blow back.

I did TDD properly the first time in my Masters Degree (ongoing). It was an eye-opener. Write your program in two different ways to make sure you know the requirements by making their outputs match. That's not me being snarky. It actually works well. Just make sure you can type quickly.

Until you have a real life scenario and are dependent on 3 external services that spit out enormous JSON's.

It's nice for writing libraries though

I still don't understand microservices for anything short of a NAG of four level architecture.

In the 25 odd years I developed software, I learnt all the rules the hard way.

Relax. You will make all the mistakes because the laws don't make sense until you trip over them :)

Comment your code? Yep. Helped me ten years later working on the same codebase.

You can't read a book about best practises and then apply them as if wisdom is something you can be told :)

It is like telling kids, "If you do this you will hurt yourself" YMMV but it won't :)

4 kings.

Wipe if you think you can do better :) It can and has been done.

4 horseman, you're welcome.

Interesting they had to redistribute the numbers to take account of its natural bias.

Sort of crazy they didn't test it for bias before they released it!

I just throw 17d6 and subtract 2.

Problem solved.

(I am joking!)

Joking aside, is throwing 2d10 and using one for tens and one for units different from throwing 1d100?

Throwing 2d10 of different colors is equivalent of trowing 1d100. It's nice they have different colors to avoid discussions, but you can throw them in two different bins or one at a time or something. Remember to sum them as (x-1) * 10 + (y-1) + 1, that is a clear indication of why zero-based indexing is better.

(Does someone sell "decade" dice, which faces say: 10, 20, 300, ..., 90 and 100?)

> (Does someone sell "decade" dice, which faces say: 10, 20, 300, ..., 90 and 100?)

Yes, they do. I used to use them for this exact purpose.

E.g.

* https://boxcarsandoneeyedjacks.com/product/10-sided-decade-d...

* https://extrememathgames.com/product/10-sided-decade-dice-00...

Cool, they also have dice with up to 5 zeros, to build your own 1d-million. I have sizable dice collection but I have never seen a 1d1000000 in person, I need to get one...

Yes, decade dice is fairly standard these days.

Usually you buy 1 D10 and 1 decade dice, and role both of them and add them. Most purchaseable dice sets come this way.

This is just the first result with a picture, but they are really common, all my dice sets have one: https://www.dicegamedepot.com/10-sided-tens-opaque-dice-red/

almost all d10's are zero-based, 0-9. And the "decade" die is 00-90. So it's just a simple matter of adding the rolls, no complicated math. And 0=100.

> (x-1) * 10 + (y-1) + 1

Is that not equivalent to:

> (x-1) * 10 + y

or:

> x * 10 + y - 10

I agree, but I'm just now porting a program from fortran to python. They read and write files that use their own convention about indexing and values [1]

And some changes may have to been backported, and it has a lot of tricks with index of arrays of different dimensions, so I'm wrapping the formulas with +1 and -1 and hopping the best.

IIRC the python compiler does not optimize them (perhaps with numba?), but later steps in other programs are slow, so N <= 20 and whatever I do is bounded by 20^4.

[1] If the file says "1 2 7.0 \r 1 2 8.0 \r" should I keep the sum (15.0), the first (I never seen that) or the last? (Raising an error, nah.)

I would say yes, because the physics of rolling two objects is slightly different than one object. I don't have any idea, though, if that would affect the distribution of numbers rolled. It's not an experiment that can be done through simulation.

You mean 20d6 and subtract 20? :P

Good luck to him. If he was behind the Neo, then he deserves the post. That's the perfect new product in the mac world.

I always enjoy these summaries. I took my bachelor of computer science in the early 1990s. It covered a language in most of these categories.

We didn't learn APL (Who is teaching the use of those custom keyboards to 100s of young students for one semester?)

The processing power of systems at the time made it clear which language classes were practically useful and usable for the time and which were not.

Prolog ran like a dog for even simple sets of logic.

We had the best internet access and pretty powerful desktop systems for the time.

I'm still curious why we didn't learn smalltalk. Could have been the difficulty of submitting and marking a system in a particular state rather than a file of code :)

> who

Yale :-) Alan Perlis' intro to CS at Yale back in the late 80s was an APL class (a relatively small one, though.)

A Smalltalk implementation provides:

    Smalltalk VM 

    Smalltalk image file 

    sources file (plain-text original source code file) 

    changes file (plain-text change log, initially empty)

So there are plenty of ways to submit code to be marked.

See "OU LearningWorks: a customized programming environment for Smalltalk modules"

https://ieeexplore.ieee.org/document/841064

Virginia Tech at least used to - the school of Architecture had a programming in APL class.

That's amazing. I used to live under an architecture student (our building). His command of design history was great. His command of maths? Well, not so much.