pyjarrett · HackerTrans

pyjarrett

674 カルマ登録 5 年前

投稿

Software and AI – Plotting vs. Pantsing

pyjarrett.github.io

1 ポイント投稿者 pyjarrett3 日前1 コメント

2026 Annual C++ Developer Survey "Lite"

isocpp.org

1 ポイント投稿者 pyjarrett3 か月前0 コメント

Ada/Spark Crate of the Year 2022 Contest

blog.adacore.com

1 ポイント投稿者 pyjarrett4 年前0 コメント

Ada/Spark Crate of the Year 2021 Winners Announced

blog.adacore.com

8 ポイント投稿者 pyjarrett4 年前0 コメント

コメント

2 か月前議論

> I tend to run older hardware,

> the tool is so fricken slow.

How old is "old hardware"? I've had no issues running CLion on a 2020 M1 Macbook Air and a i5-10400 (Linux). These projects are only in the hundreds of thousands of lines of code though.

> The install is gigantic on disk, leading me to avoid it on my older machines where space is limited.

I found that by default toolbox likes to keep old versions of the IDEs available for rollback. I disabled that and reclaimed tens of GB across all the products I use.

3 か月前議論

Ariane 5 became one of the most reliable rockets ever made and was used to launch the JWST.

4 か月前議論

I used to, but the knowledge of .NET seems mostly transferrable to C#. It's super useful to do `dotnet fsi` and then work out the appropriate .NET calls in the F# repl.

4 か月前議論

These are the big ones I use, specifically because of the standard libraries:

Python (decent standard library) - It's pretty much everywhere. There's so many hidden gems in that standard library (difflib, argparse, shlex, subprocess, cmd)

C#/F# (.NET)

C# feels so productive because of how much is available in .NET Core, and F# gets to tag along and get it all for free too. With C# you can compile executables down to bundle the runtime and strip it down so your executables are in the 15 MiB range. If you have dotnet installed, you can run F# as scripts.

4 か月前議論

It doesn't take much power or time to run your own local git server. My first one which lasted years was parts I mangled together from old computers from garage sales.

There's instructions on running a Git server in the git book: https://git-scm.com/book/en/v2/Git-on-the-Server-The-Protoco...

6 か月前議論

https://pyjarrett.github.io/

昨年議論

I played an incredibly amount of SimCity 2000 and SimCity 3000, and Metropolis 1998 looks *amazing.*

昨年議論

FASTBuild[0] is super fast for large projects and comes with distributed builds and caching out of the box. It requires a bit of effort to set up, but it supports globbing sources, there's no separate generate build step, and it can also make Visual Studio solutions.

[0]: https://www.fastbuild.org/docs/home.html

昨年議論

Another great resource for vets getting started in software development (and other fields) is American Corporate Partners[1]. I had a great mentor through that group.

[1]: https://www.acp-usa.org/

昨年議論

> However, existing programming languages have little or no subtyping

Every "type" you use in Ada is actually a subtype.

In Ada, "A subtype of a given type is a combination of the type, a constraint on values of the type, and certain attributes specific to the subtype".

You don't ever refer to actual types in Ada, since creating a type with "type" actually creates an anonymous type and the name refers to the first subtype.[1]

    type Token_Kind is (
       Identifier,
       String_Literal,
       --  many more ...
    
       -- These are character symbols and will be part of Token_Character_Symbol.
       Ampersand,
       --  ...
       Vertical_Bar,
    );
    
    --  A subtype with a compile-time checked predicate.
    subtype Subprogram_Kind is Token_Kind
    with Static_Predicate => Subprogram_Kind in RW_Function | RW_Procedure;
    
    subtype Token_Character_Symbol is Token_Kind range Ampersand .. Vertical_Bar;

> If you have a pointer with more permissions, it should still be usable in a place that only requires a pointer with fewer permissions

This is exactly how "accessibility" of access types works in Ada[2]. If you have a pointer ("access type") to something on the heap, you can use it wherever an anonymous access type can be used. You can also create subtypes of access types which have the constraint of a "null exclusion".

[1]: https://ada-lang.io/docs/arm/AA-3/AA-3.2#p1_3.2.1

[2]: https://ada-lang.io/docs/arm/AA-3/AA-3.10

昨年議論

> no one cared back then if he was real,

This was directly addressed in 2 John 7

"I say this because many deceivers, who do not acknowledge Jesus Christ as coming in the flesh, have gone out into the world."

昨年議論

> Plenty of ways to trigger undefined behavior

I'm curious about this list, because it definitely doesn't seem that way these days. It'd be interesting to see how many of these are still possible now.

昨年議論

Ada

The open source tooling has significantly improved since I started using it in the last five years.

2 年前議論

About two years ago, I was able to dive into the Ada reference manual formatter which has initial commit of March 2000 and is about 45k lines of code, and add MDX output pretty easily.

Other languages focus on terseness and expressiveness. Ada expresses a bunch of constraints directly and forces you to do things in organized ways (e.g. use namespaces appropriately).

2 年前議論

The big reason for `out` only is "I want to write here, but I don't care about the initial value." It's a more explicit version of the C++ `Foo& outFoo` output parameter paradigm.

> When "out" and "in out" parameters are distinguished, there is no need for the existence of constructors as a separate concept.

I don't agree with this. You can get I need to do things "post-init" with controlled types, or use a `return X : Thing do ... end return` block. Constructors help ensure invariants. You can make a type `is private` to prevent instantiation, only allowing creation via functions (sort of like Rust `new` associated functions), or initialization via an `out` param. It's OK but not perfect, but you can also tag on a `Type_Invariant` aspect if there are conditions which have to be met by a type. My big problem with Controlled types is that forces a type to be `tagged` (i.e. it has a vtable) which means it affects storage layout of values of that type, which isn't a problem in C++.

You can forbid copies by making something a `limited` type, but you'd have to write your own "Move" equivalent, and some of the containers have `Move` subprograms implemented to transfer contents. Limited types might elide the copy when returned from a function, but it's been a while since I looked at those rules.

2 年前議論

I recently started writing Ada again, a couple of years after I did a bunch of projects with it. The amazing things is how easy it is to go back and update old code due to how much semantic information gets embedded in it and how few symbols it uses.

2 年前議論

That's because I took it down over two years ago and moved most of the content to ada-lang.io when I set that up. This was an anecdotal blog post so it didn't get moved over.

2 年前議論

Ada syntax is close to what you described:

    Foo : array (Positive range 1 .. 100) of access function return access Integer;

2 年前議論

Ada is used quite often in embedded systems.

- https://blog.adacore.com/ada-on-any-arm-cortex-m-device-in-j...

- https://github.com/AdaCore/Ada_Drivers_Library

2 年前議論

> you don't have to go full functional verification

The amazing thing to me is that Ada code can call SPARK code just fine, and there's crates of SPARK code in Alire that you can use. It's a huge boost of confidence in the quality of a library that you're using when it has some form of verification.