@mcc does it have a y'all function? Because if so, I'm switching immediately

@mcc i wonder what would happen if you put an empty file in git with permissions 0400 by like manually editing the tree object, probably nothing good. I should try it.

@mcc @tedmielczarek I had to do a lot of parsing of Fortran 77 for my first aerospace internship and was desperately trying to remember what the significance of column 6 was

https://docs.oracle.com/cd/E19957-01/805-4939/6j4m0vn6l/index.html

oh right,
"The first five columns must be blank or contain a numeric label.
Continuation lines are identified by a nonblank, nonzero in column 6."

@mcc need to go back to playing with fortran, I forgot about this...

@Petra @mcc If you're up for reading git history, a few years ago I methodically modernized a F66 text adventure to F2018. https://gitlab.com/apthorpe/Castlequest

Refactoring away 750+ GOTO statements in the main game loop was satisfying but the last 10 or so took some pretty severe architectural modification. This code is probably a worst case scenario for untangling IF/GOTO logic.

The binary save file format from 1979 should still work and the game should play about identically to the original, though it accepts both upper and lower case commands now and the output defaults to plain text without the ASA carriage control characters. Builds on Mac, Windows, and Linux with identical source code (no #ifdef nonsense) and will create native installers for each platform if the appropriate packaging utilities are installed.

@mcc @tedmielczarek Until F90, Fortran output sent to a printer or the console was assumed to have an ASA carriage control character as the first character of the line - see https://en.m.wikipedia.org/wiki/ASA_carriage_control_characters

The carriage control character would be consumed on output which meant if you started writing output without a leading space (or 0, 1, or +), the first character would get trimmed off. That's why output lines in F77 and earlier start with an extra space - it's a control code for a long obsolete printer formatting scheme.

To get proper formatting of legacy FORTRAN output, POSIX included the `asa` utility: https://www.man7.org/linux//man-pages/man1/asa.1p.html

Back in the day I made friends with the head of Design Engineering at the power plant where I worked because I knew the obscure magic to make his department's code output legible and not look like total ass. I didn't have much interaction with him otherwise but I was always happy to help him sort out his code output. Good guy.

@arclight @tedmielczarek oh damn i wasn't actually expecting to get an answer. thanks lol

@b0rk *thinks*

i may or may not understand what you're proposing. however someone elsewhere in the thread said that the git on-disk format only represents one "readable?" bit per object (IE, it flattens the three-user-category UNIX permissions model to one category), so if that's true it might be there's not actually a way in the format to do the thing you just said.

@arclight @mcc this thread has been a delightful goldmine of weird Fortran trivia. I doubt any of it has helped Andi make her program work, but I hope it has at least made it clear that the problem is Fortran, not her.

@tedmielczarek @arclight i guess i'm actually doing this more to pick up weird fortran gotcha facts than i am to get a working program…

@mcc but you could rewrite the test to programmatically create a file without read permissions…

@gretyl thank you for suggestion but

https://mastodon.social/@mcc/113920886487184925

@mcc You may be missing a call to COMMAND_ARGUMENT_COUNT() which gives you the number of arguments https://www.intel.com/content/www/us/en/docs/fortran-compiler/developer-guide-reference/2023-0/command-argument-count.html

Be aware the Fortran I/O is record-oriented. Streams are a C thing from the early 1970s - you have to jump through a lot of hoops to get stream I/O working in Fortran. It's not worth the hassle.

There's a certain subtle and archaic magic to Fortran I/O and for greatest happiness, do not expect it to work like C. In fact, forget that C even exists.

Array indices start at 1 because normal people start counting at one, not zero. (You can set the index bounds of an array to anything you want but you will absolutely regret it.)

Arrays are in column-major order which is pretty much opposite every other language you've used. This will likely trip you up.

Say you've dimensioned A(2,3,5) - 30 elements total in three dimensions or 'ranks'. You'd be tempted to nest loops outer to inner as i=1:2, j=1:3, and k=1:5 and reference elements as A(i,j,k) in the innermost loop. This will have awful memory lookup performance because i is the fastest moving index, followed by j, followed by k. You will typically see nested loops arranged like

do k = 1, 5
do j = 1, 3
do i = 1, 2
A(i,j,k) = whatever()
end do
end do
end do

Note that if whatever() returns a scalar, you could just do

A(1:2, 1:3, 1:5) = whatever()

or

A(:,:,:) = whatever()

or just

A = whatever()

And get the same behavior without having to worry about efficient memory access. Array operations are your friend - welcome to vectorized (SIMD) optimization with zero effort on your part. Need to initialize A to zero? `A = 0.0` and you're done.

Oh, and numeric types matter. A lot. 3 / 2 = 1, not 1.5. Why? Because integer divided by integer yields an integer. 3 is different from 3.0 which is different from 3.0d0. More formally, these three literals are 3_int32, 3.0_real32, and 3.0_real64 (iso_fortran_env contains definitions of 'kinds' for each of the numeric types.) Type and kind inference and compatibility rules are another rabbit hole of complexity. Remember your discovery of the aint() function? There is also dint() which converts real64 (aka 'double precision') to int32. aint() and dint() are deprecated; int() has some multiple dispatch magic to send whatever numeric type you pass in to aint(), dint(), etc. under the hood. This is another rabbit hole of the Fortran type and object model but for now, all you need to remember is to use the generic forms of int() and real() and to be careful specifying numeric literals. This is a language that cares very deeply about numeric precision and it expects you to be explicit about what you want. It's very good about giving you what you ask for but it also expects that you know what you're asking for. Every new Fortran programmer almost immediately gets bitten by the 3 / 2 = 1 issue. Computer math is very different from formal math, ℤ is not a subset of ℝ here - they are distinct and not necessarily interchangeable or compatible.

This brain dump is getting way too long. Sorry about that.

There are file units, not file handles. FORTRAN was developed for the the IBM 704 which did not have a CRT (in that era, a CRT was more likely to be a memory device not a display). Historically, units may be console, keyboard, printer, tape (magnetic or paper), disk, card punch, card reader, drum, or disk. By convention, console input is unit 5, console output is unit 6. You've already discovered iso_fortran_env which formalizes this convention with standard names.

iso_fortran_env is basically half of Fortran's standard library. There are a few others, mainly relating to IEEE math and C types for cross-language programming.

One of the irritations with Fortran was the need to manually keep track of which unit numbers were previously assigned or in use (like 5 and 6). Good practice today is to define an integer variable to hold the unit number and pass that to open() under as the newunit argument. open() will find a free file unit and store it in the variable which you'll basically use as a file handle.

Fortran is very good about named arguments to functions and I find it helpful to be a little pedantic and wordy to explicitly name all the arguments passed to functions. `read(6, 10) J` becomes `read(unit=6, fmt=10) J` so it's clear which is the unit number and which is the edit descriptor (another deep rabbit hole of Fortran I/O...)

@arclight The problem I had was not the number of arguments but rather getting the length of a single argument

@mcc @b0rk "9-bit unix permission. Only 0755 and 0644 are valid for regular files"
https://github.com/git/git/blob/master/Documentation/gitformat-index.txt#L94

@mcc @b0rk is there a reason to avoid having your testcase make a temporary file with the appropriate permission?

@ellie @b0rk the test case is an inert text file. i do not have executable test cases, and the program is too trivial and temporary to justify setting up a test harness.

@mcc I'm a little late to this thread and I see you've already both solved your issue and received all the usual advice about making your test scripts initialize the file permissions they require, but I don't think I saw anyone mention this slightly more esoteric solution:

https://github.com/git/git/blob/master/contrib/hooks/setgitperms.perl

Git has included since 2006 a contributed post-checkout/post-merge hook script to apply extended permission & user/group ownership settings stored in a .gitmeta file in the repo root. Rarely useful!

@b0rk @mcc likely nothing good, git only really supports 755 and 644 as modes

https://github.com/git/git/blob/master/object.h#L132

@tef @mcc yeah I'm sure it's nothing good, I'm just curious about how exactly it would fail

(technically tree objects are text files and you can put "0400" as the permission, it's just not a valid value)

this is the format:

100644 blob e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 empty.txt

@b0rk @tef Oh no

@mcc @tef I tried and it seems very hard to get git to do this, it'll just change the permissions to 644 (which is probably for the best)

https://gist.github.com/jvns/4d27efda9fe598a765481464cd2ac69c

Decided to do a bit more on the FORTRAN project this morning… found myself running in circles for a decent bit trying to understand why code wasn't acting the way I expected. I eventually realized the problem was that when I wrote the expression `char_in == '\n'`, this was behaving differently than I expected because '\n' is a string containing a backslash followed by an n. Of course it is. Of course? Why would I have expected it be anything else?

@b0rk @mcc I just tried it with this method:

```
git init '.'; touch 'fn'; chmod 644 'fn'; git add 'fn' && git commit -m 'byte crimes pt.1'; git branch 'byte-crimes' "$(git commit-tree -m 'byte crimes pt.2' $(git ls-tree HEAD | sed -e 's/^100644/100400/' | git mktree))"; git ls-tree 'byte-crimes'; git cat-file tree 'byte-crimes' | less
```

The result is that the tree object will contain 100400 permissions, but at read time you get 100644. `git fsck` returns only a warning about the crime.

On a related note, shortly after this I was in a situation it would be convenient if I could cause a particular loop iteration to abort and resume from the beginning of the loop. I experimentally typed "continue". It was accepted. I run the code. It does not behave as I expected. I go to look it up.

@mcc RTFM would save so much stumbling in the dark. Why do you do this to yourself?

@mcc If you are trying to manually control seek and advance with Fortran I/O, you are going to have a very bad day. Fortran I/O is record-oriented and handles a lot of EOL detection and parsing for you. You should not be implementing fprintf() because write() and format() will do basically everything you need.

character(len=32) :: mystr
character(len=:), parameter :: fmta32 = '(A32)'
read(unit=5, fmt=fmta32) mystr

will read up to 32 ASCII characters from console input into mystr. If you give it fewer characters, the remaining characters are padded with blanks; no need to trim \n. \n is a record separator, not part of the record. You will never see it.

If you give it more than 32 characters, mystr is filled with the first 32 characters and the rest of the characters are ignored. You don't have to worry about \0 because mystr is fixed length; \0 never enters the equation because this isn't C. Try to force a buffer overflow all you want - mystr is 32 characters long by definition and there's nothing anyone can do to change that.

None of this changes if you change the edit specifier in fmta32 to '(A)' - mystr gets at most 32 characters because that's how it's defined.

"But I don't know how long my incoming string is!" I would suggest this is a problem with setting requirements because I very sincerely doubt you can't set a reasonable upper limit on your input. I know, it's heresy in modern computing to set hard limits but that opens us up to lazy wasteful design. Is this input a path? Take the longest path on your filesystem and double it - done. If it breaks for someone, refine requirements and modify the code.

"But then every string I read will be huge and I'll run out of memory!" Fine; read each input string into a big fixed string then use adjustl() and trim() to left-justify and trim trailing spaces and stuff the results into an allocatable character variable. You pay for that with some memory accesses (time) but you save on memory (space).

"But I don't want to spend the time copying the data!" Ok, are you sure you want to do massive amounts of text processing in a language oriented toward numerical computation? You might want to rethink your choice of implementation language. Or punt this function off to another language and link to it via Fortran's interface to C. Or you might be prematurely optimizing - how much do you understand about how your code will be used in practice? Do you have an actual performance problem or a reasonably predictable issue? If not, maybe deal with that if/when it arises.

The same issue arises when dealing with arbitrary-length lists of input. I often deal with this sort of issue by reading input into a linked list, counting the elements, allocating a variable-length array, copying the elements over, then deleting the linked list. There's no standard library of collections and data structures so it's DIY or do without. It sucks but nobody wants to spend unpaid effort to build consensus on what goes into a curated standard library and push it through the Fortran language committee. I'm convinced that the only language features that get added today are HPC conveniences for the nuclear weapons complex (see coarray Fortran) - whatever the people paying for large numbers of Intel Fortran licenses want.

Regardless, Fortran input is straightforward if you are reading mildly formatted text files and picking out short strings and numbers. Pretend you're reading from a stack of punch cards - the length limit is far larger than 80 characters but input goes through an implicit readline() step so you never see \r or \n.

You can also open array of strings as a file and use read() and format() for parsing - the keyword to look for is "internal file". I mean, if you really need to write a recursive descent parser but also have random access to the source lines, you can do it. Scanning is a little weird but it's completely doable.

Output is similarly record-oriented - if you're trying to write without advancing, consider compositing output to an allocatable character string; just write the string when you're done appending to it. The edit specification minilanguage can do basically whatever fprintf can do without nearly as much weird punctuation. Just don't expect it to act like stream I/O; this is an application oriented language not a low-level systems language so you don't get (or generally need) fine seek control. You get rewind() and that's about it.

@arclight The input is a grid of ASCII characters.

https://github.com/mcclure/aoc2024/blob/stable/04-01-wordsearch/data/sample-2.18.txt

I am finding STREAM mode from FORTRAN 2003 entirely adequate so far.

@hyc I have no idea what you are trying to communicate here. The screenshot above is literally a screenshot of the manual.

@gnomon ahh interesting!

when I try to look at the tree object with `git cat-file -p` it gives me different permissions than when I cat the object

$ cat .git/objects/ab/db86eedd4a6e24cf91b286bfde0f040e2b7441 | zlib-flate -uncompress
tree 30100400 fn�⛲��CK�)�wZ���S�⏎ $ git cat-file -p abdb86eedd4a6e24cf91b286bfde0f040e2b7441
100644 blob e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 fn

@mcc I mean read the language text thoroughly before trying to write it. Instead of guessing and looking up your mistake after the fact.

@b0rk exactly, that's what I meant about it appearing to be normalized at read time - like you can put any old garbage in that field but git will just default to treating it as 100644 if it doesn't match one of the other formats it deigns to support.

Bee tee double you, did you see this wacky hook that nobody has touched in twelve years?? https://github.com/git/git/blob/master/contrib/hooks/setgitperms.perl

@hyc Typing a nine-letter word, identifying that the syntax highlighter didn't bold it which is suspicious, and running the program once to see what happens is not exactly a substantial investment of time.

@gnomon wow that's wild

(So there's no confusion: I think this is a fine feature for a language to have, I think every language should have a "no-op" keyword, it's basically the same as Python "pass" and exists for the same reason [as a target for otherwise-productive flow control] [GOTO labels must point to statements, so you need a way to write a statement with no effect])

@mcc nice! so I don't have to throw away all my (subsequent) punch cards if I need to remove a line of code. I can just replace it by a continue! Love the UX in this language

@stsp yes but what git supports and what it'll actually *do* are two different things, come join us in committing byte crimes

@hyc @mcc Oh I dunno. I always learn a language better when I guess because you start to get the feel for it.

I think a "go to" statement might work here? but it's been 20-some years since I wrote anything in Fortran

@aadmaa @hyc i do not at this time require assistance

@lambdageek 0x90909090909090909090

@mcc you see, it continues executing the code as requested

@vv Reckon so

@mcc you can do command-line arguments in Fortran now? Sheesh, my wasted years of wrapping Fortran code in DCL/Shell scripts that renamed input files to FORT.N input channels and renaming output files to something sensible on exit ...

@scruss FORTRAN 2008 has a lot of QOL improvements

@mcc I wonder if it could have also been useful as something that could have easily been replaced with a GOTO as a patch without having to redo a ton of paper tape or punch cards long ago.

@aadmaa maybe guessing works out when you're already familiar with similar, contemporary languages. But you have to understand them in context. Fortran, and CONTINUE in particular, predate the concept of structured programming, and obviously has no similarity to its loop control meaning in more modern structured languages.

@mcc @arclight if you chose COBOL instead you could have wound up with a lucrative career!

@stsp hah!

To be fair, you're in good company: git isn't git-fsck clean either, not by a long shot.

OK so

I am using the stream input mode for my file input (this freaks the fuck out of every FORTRAN programmer on this site, but)

I need to seek to the beginning of the file. A stack overflow comment suggests this is done with

read(10, "()", advance='no', pos=1)

gfortran prints

runtime error: Format present for UNFORMATTED data transfer

I remove the "()"

read(10, advance='no', pos=1)

Compiler balks

Error: the ADVANCE= specifier at (1) must appear with an explicit format expression

WDID

@mcc Someone found a way to run scripts after git clone. https://github.com/git-hook/post-clone

Tested with the non curl | bash method, and this in my_repo/hooks/post-clone https://paste.xinu.at/q9i

Man if I found a second case where GNU Fortran failed to implement the standard standardly I'm gonna be annoyed

My fuzzy read of the standard is that the "()" version above is probably inaccurate, but the version without the "()" should probably in this case compile.

I'm actually kinda stuck here, and this (the ability to seek within a file) is a banner feature of the post-2000 STREAM mode, so I think: I wonder if there's a Discord, IRC, otherwise realtime communication channel for FORTRAN programming I could tap.

https://fortranwiki.org/fortran/show/IRC

*squeaking" "No… no!!!"

There are some ways that being stuck in 2008 are good but this is not one of them!!

@mcc The UK research software engineering Slack has a Fortran channel, you can request to join at https://docs.google.com/forms/d/e/1FAIpQLSdqs-_QNwQFzCIUEafah91E5E00lGUEnTPC4jjYbGUqPjONwA/viewform

@h0m54r Heh, neat.

Given this still requires a roundtrip before I can post a question, I might just go ahead and finish this with workarounds and then email the GNU mailing list.

I successfully worked around gfortran's apparent refusal to do a nonadvancing read by having my actual read look like

if (row_at == 1 .and. col_at == 1) then
! If we detect this is the first character of the file, reposition
read(10, iostat=file_error, pos=1) char_in
else
read(10, iostat=file_error) char_in
end if

But I really, really, *really* hate it

@mcc low level libraries are made of hate

I am experiencing confusion about apparent disjoint between docs and behavior. Is the following correct?

! This allocates a matrix "board" of COLS columns and ROWS rows
allocate(board (cols, rows))

! This writes to the "bottom right" cell of board
board(rows, cols) = 1

Everyone agrees FORTRAN is column-major in memory but get vague about syntax (lots of examples where indices are named "i" and "j"). I get incorrect behavior if I DON'T swap rows,cols order between allocation and write/read.

@mcc (Actually, thinking about it, UKRSE is also in the process of taking on on the Fortran standards working group from the British Computer Society, so it makes sense as a home for discussion. I know some channels on that server are bridged to Matrix, but I don’t think the Fortran one is currently unfortunately)

@mcc That doesn’t seem right to me, I expect the indexing to be the same ordering in allocation and indexing.

@mcc Did you try:

read(10, pos=1)

That's what the example code for stream I/O seems to use.

@jhamby but won't that perform a read?

@jhamby this is how i did it

https://mastodon.social/@mcc/113924441031677358

Blghgafhg part 1 done. This was the longest any part 1 took me of this project so far, but I think that was mostly… external distractions, happening this week. Gonna do part 2 before I share my thoughts (part 2 is really simple but I'm going to do it a little more complicated than it has to be just so I have an excuse to do some vector math in FORTRAN)

All right.

Part 1: https://github.com/mcclure/aoc2024/blob/ca77f141f33ab494dc1bb43f3d6f13e775a36303/04-01-wordsearch/src/puzzle.f90

Part 2: https://github.com/mcclure/aoc2024/blob/ca77f141f33ab494dc1bb43f3d6f13e775a36303/04-02-wordsearch/src/puzzle.f90

Did I learn anything from this? I guess. Yeah. Okay, I guess so.

That wasn't particularly unpleasant. The ergonomics weren't great, but were not-great in forgivable ways. The fact each tutorial/doc/StackOverflow answer I found targeted a different FORTRAN std was definitely frustrating. I got to add an array to an array on two (2) lines of part 2, and other than that this was basically funny-shaped C. C with paperwork

The v.a.s.t. bulk of the time here (and in the simpler part 2, the bulk of the code) was spent on file I/O. In the 4 weeks of this project so far, I skipped file i/o (instead embedding the data in the program) for BASIC and ASM, since those are languages with Limitations, and for Forth and FORTRAN I assumed those were Fully Featured so I could just do file i/o. But no, on both Forth and FORTRAN simple file i/o was *a nightmare*, the bulk of the work.

(1/2)

There's an awkward irony here.

For the Forth week, the input was a list of ASCII numbers. *This* kind of input FORTRAN had easy-to-use builtins for, but Forth had nothing and I had to build it myself.

FORTRAN week, the input was a grid of ASCII characters. *This* Forth could have handled pretty easy, but FORTRAN it's actually sorta impossible unless you use a modern (and, apparently, not completely tested in gfortran??) "stream" mode, which took forever and required consulting the spec. (2/2)

I got a lot of good help this week (FORTRAN) so, thank you everyone.

I guess that's one "month" of the project down. Here's my completion status.

(Note there are 43 languages on this list, and 25 puzzles in AOC, so only a little over half will get hit by the end. My "for certain" list is: TCL, Haskell, Idris, Smalltalk, Self, Ada, Factor, Mirth, Uiua, at least one of ARM and RISCV.)

@mcc Fortran is good for high performance multidimensional array work. But for easy multidimensional work you might want to look into array languages.

But then again, one had a lot of fun reading this thread, so going with Fortran was clearly the right choice. 😃

@loke Among the problems here are

1. I don't know what puzzles might be coming later in the set; if I see a non-numerical multidimensional array program and so hold off on FORTRAN because maybe there'll be a good numerical problem later, well, maybe there actually *won't* be.

2. I don't ever know what part 2 will be when I start part 1;

3. I don't truly know what the different languages are good at until I've used them! And that, more than anything else, is the point.

@mcc Julia is kinda cool, though I've only played with it a bit. It's fairly new and has been rapidly improving. Worth checking out, I think. Best for the more numerically oriented problems.

@not2b I actually around 2013 auditioned Julia as my new scripting language to replace Lua. It was interesting but once I realized I couldn't embed it in an executable without embedding the 44MB entirety of LLVM I walked away. This, along with difficulties getting the Clasp compiler to run on my old laptop, was what eventually lead me to create Emily (a language that turned out unsuitable for games as the one game I wrote in it initially ran at 1 FPS)

@mcc definitely. And you documenting it here provided not just entertainment but also valuable information for those of us who might want to go down a similar path in the future. I'm certainly open to using Fortran for solving some problem where its strenghts are useful. But since I've never actually used it beyond simple hello world style programs, these kinds of threads are useful. And not to mention, fun.

I solved 2024 in my own programming language which happens to be an array language, so seeing the Fortran approach was educational.

@loke definitely try to use the 2003 edition or newer, is what I learned.

@mcc what’s the challenge?

@paulywill https://mastodon.social/@mcc/113676228091546556

@mcc Tcl is so fun, what an odd little language

@capn_b i actually kinda need to learn that one

@mcc I'm so curious to see how TCL, Haskell, and Smalltalk go 😄

@megmac this is gonna be my like third or fourth attempt at haskell, and i've somehow been reading smalltalk tutorials since the year 2000 without ever actually writing a line of it

@mcc I think all three are really great "platonic ideal" languages of their respective paradigms but that makes them kind of low key miserable to use in practice so that checks out.

(But I have also never written Smalltalk in any significant amount. The whole "image" thing makes me uncomfortable)

@mcc That has changed with newer versions.

@not2b Neat.

@megmac @mcc I'm looking forward to COBOL. Mainly because I've been playing around with it recently.

It's remarkably not terrible in some ways (and very annoying in others). In fact, the aplit between nice and horrible appears to be exactly opposite that of FORTRAN.

@loke @megmac I don't promise I'll do COBOL.

@mcc Ooh, I hope you get to one or more of Tal, Gleam, and Zig, those have all been really fun to learn!

@soxfox42 there are several reasons I should learn Zig.

@mcc I did a lot of work in Ada back in the day, so I’m keen to see what you do with it.

@mcc I was just reminded of the existence of xslt and I think you should add that to this list if you've never used it before.

@megmac I actually made a good faith effort to implement a lambda calculus evaluator in XSL/T once

@mcc @mark @xgranade For C DSPs were one of the big holdouts with unusual byte sizes AIUI - the users didn’t really care about data not represented as a word so no point implementing the hardware to handle that efficiently.

I'm not doing the Babel-of-Code challenge this week but Andrzej has his writeup of his Prolog week up

https://mastodon.gamedev.place/@unjello/113935017360726890

and has started a thread for his week with Lean:

https://mastodon.social/@unjello@mastodon.gamedev.place/113935056291728976

@wouter ah yes, one of my projects has a symlink to a parent directory in it in order to avoid a build step to copy some files into the scope of some framework, and, this is not a good idea

@wouter the unix filesystem is a tree which is actually a cyclic directed graph, good fun