❌ About FreshRSS

Normal view

There are new articles available, click to refresh the page.
Before yesterdayGautier's blog

Pasta! - Level 34

12 March 2019 at 18:13
First of all, ladies and gentlemen, welcome to the newcomer, the fusillone:

The new pasta makes its first appearance in level 34 of the Pasta! game.

Caution: it's a Piccante level, which means it's a tough one.
Here are a few hints about how to tame it.

  • There are lots of moves at start (30), so your fate is (mathematically speaking) quite divergent: perhaps you'll be very lucky quite early, perhaps not at all. Don't give up, and try again!
  • Spot the 4's, the L's and T's early to earn points, even if all this basil is still blocking you (usually the tactic is to get rid of obstacles first)
  • Try to clear as much basil as possible in single moves (like the three fusillone on the bottom left in the picture)
  • Once there is more room on the plate, don't forget the general rule of these kind of games: do matches on the bottom, so you trigger more chain reactions.
  • Remember that there is an infinity of lives in this game, and that you can restart a level at any time either by clicking on the map, but, even easier, by clicking the Reload button!

As a bonus, here is the development Pasta! server, running from the GNAT Programming Studio (GPS), with level 34 as source code.
Click to enlarge

Pasta! - Level 35

17 March 2019 at 19:47
Level 35 of Pasta! is easy.

However you'll notice the redoubtable Antipasta hiding below basil layers.
Still, they can trigger nice chain reactions...

Pasta! - level 35
As a bonus, I've written down how much time it took to build this level.

  • 7 minutes from the sketch on paper to Ada code, using two editors: LEA and GNAT Programming Studio (GPS) including debugging: Ada detects at compile-time bugs like size mismatches or type errors. The only run-time issue was an infinite loop with rows of identical Antipasta. Perhaps it is a bug, or there are really no possible combination without immediate match for the startup board. I did not look into this.
  • 15 minutes testing the first version, which was a bit boring with nine columns and too few pasta sorts - that is, too many pasta of the same kind.
  • After reducing the number of columns from nine to seven and increasing the number of sorts of pasta, it became much funnier.
  • After v2 (2 minutes of testing), came v3 (7 minutes) and a few others (30 minutes in total) with always smaller fine-tuning for the number of rounds, the threshold in points, that corresponds to an easy (but not too easy) level.

AZip 2.35

3 August 2019 at 17:29
New AZip features since v.2.25:
  • Select columns menu entry allows you to select the columns that you find useful to be displayed (v.2.30)
  • Option for a default extraction directory (v.2.31)
  • Drag & Drop from a folder within AZip, to Windows Explorer or to the Desktop (v.2.35)
  • Context menus within AZip (v.2.35)
Visit AZip home page here.

Column selection - click to enlarge

Option for a default extraction directory - click to enlarge

Context menus with AZip - click to enlarge

New GitHub mirrors

17 September 2019 at 08:32

New GitHub mirrors, for open-source projects I'm administrator or developer of, are located here.
Please ignore the old mirrors that relied on svn2github. If you see "svn2github" somewhere on a repository address, it's the old one → trash it!

You can find the same projects on SourceForge too, here.

The projects are...

Ada Bar Codesbar code (1D and 2D) generator in pure Ada
Ada PDF Writera standalone, portable package for producing dynamically PDF documents
AZipa free, portable Zip Archive Manager
Corporate Bullshit Generatorthe Corporate Bullshit Generator
Engine_3Da real-time, pure software, 3D engine for DOS-talgics
Excel Writera standalone, portable Ada package for producing Excel spreadsheets
GIDGeneric Image Decoder
GLOBE_3Da real-time 3D Engine written in Ada
GNAVI: GNU Ada Visual Interfacethe GNU Ada Visual Interface
GNOGAthe GNU Omnificent GUI for Ada
HACHAC Ada Compiler
Ini file managera standalone, portable Ada package for configuration files
LEALightweight Editor for Ada
Mathpaqscollection of mathematical, 100% portable, packages in Ada
Pascal-to-AdaPascal to Ada translator
TeXCADa program for drawing or retouching {picture}s in LaTeX
Wasabeea Web browser with safety focus
Zip-Adaa standalone, portable Ada library for Zip archives

The Corporate Bullshit Generator - Business Agility Edition

2 November 2019 at 17:43
Our best-in-class, high-performance digitized business intelligence tool, the Corporate Bullshit Generator, just got a tremendous impulse thanks to no one less than Dilbert himself (see the October 28, 2019, cartoon: Business Agility Influencer) ! Here are a few gems including the new items, that the CBSG produces - by the thousands each second, beating the most talented managers worldwide and beyond !
  • The Global Chief Business Agility Officer (CBAO) influences our business process quality engineering.
  • Business agility and solution orientation empower a sales target by expanding boundaries.
  • The Chief Operations Solutionist (COS) activates a first-mover, state-of-the-art, cross-pollination across the entire spectrum.
  • An insightful say/do ratio strengthens our high-performing customer behavior patterns, whilst a hybridation quickly strengthens the mediators.
  • The Enterprise Chief Business Planning Influencer (CBPI) cost-effectively enforces synchronized assets.
  • The "why" behind visions will be best positioned to enforce our field workforce optimization.
  • Pre-integrated diversification is all about right, awareness-raising, usage-based and holistic data science innovation.
  • Our challenge is not to co-specify our Business Model Innovation (BMI). Our challenge is to call "check-mate" ahead of competition. 

    The Corporate Bullshit Generator - the Crossroads of Data

    30 November 2019 at 11:11
    Without fresh data from our fans, the Corporate Bullshit Generator could not stay at the cutting-edge of innovative data-centric business intelligence. Here are two key additions (coming from the same sentence):


    At the crossroads of supply-chain, bandwidth and reorganization, value stream management is all about business acumen.
    At the crossroads of values congruence, brand pyramid and socialization, the key to framework is technical strength.
    At the crossroads of relevance, responsibility and convergence, the General Senior Head of Management Office drives customer-centric co-innovations.



    Flat out, the standard-setters conversate by turning data into transformation processes.
    Actually, an open-door policy transgenerates our outward-looking, skills-based and up-to-the-minute success factors by turning data into superior-quality re-engineering.
    Adjacencies are on track by turning data into long-term, movements-based, rollout plan.
    The science-based action fosters our integrative document; this is why industry market shifts accelerate the analytics-based, hypothesis-driven, top-level and diversified case study by turning data into synergization.
    The product manager potentiates corporate data practices by turning data into trigger events.
    The enablers ignite our accountability by turning data into workforce adjustments.
    The standard-setters differentially right-size pipelines by turning data into business equation.
    As the consumer and commerce landscape continues to evolve, the group targets our frameworks by turning data into convictions.
    The Senior Vice Director of Facilities Management envisioneers scalings by turning data into cross-functional synergies.
    Our sourced say/do ratios influence the game changers by turning data into infrastructure.
    In order to improve, you need to promote advanced-analytics and first-mover support structures by turning data into outstanding issues.
    The stakeholders cost-effectively overcome our problems/difficulties by turning data into mind-blowing core values.
    To remain relevant, the Enterprise Chief Value Added Services Officer (CVASO) filters out our limitations by turning data into predictability.

    Thanks for the input - and enjoy!

    Never lose your progression with Pasta!

    9 January 2020 at 00:08
    If you clean your browser's Local Storage data, or change browser or machine, you'll lose your progression in the game. That should not happen (again)!

    So, on your next Pasta! session, rush to the small "avatar" icon, shown here by a blue arrow.

    Then, copy your Player Code into a safe place. For instance, send it in a mail to yourself.

    That's all!

    By the way, you may want to change your nickname...

    HAC - some progress

    4 April 2020 at 13:28
    Work on HAC (the HAC Ada Compiler) is ongoing. The focus is slowly shifting, from code cleanup and clarification, to adding features (recently: explicit numeric type conversions) and fixing bugs.

    About HAC

    In the Ada world, we are surrounded by impressive and professional tools that can handle large and complex projects. Did you ever dream of a tiny, incomplete but compatible system to play with? Are you too impatient, when developing small pieces of code, for long compile-bind-link-run cycles? Are you a beginner intimidated by project files and sophisticated tools? Then HAC (the HAC Ada Compiler, the Hacker's Ada Compiler, or the Hello-world Ada Compiler) is for you.

    HAC is a revival of the SmallAda project, which supported the "Pascal subset" plus tasking.

    HAC was presented early 2020 at the FOSDEM conference.
    The presentation is available as PDF and PPT.

    Here is a screenshot of the SmallAda parser (written in Pascal):

    and the equivalent status of HAC (which originated from a translation of SmallAda through the Pascal-to-Ada translator):

    HAC - removed implicit type conversions!

    6 April 2020 at 18:47
    More progress on HAC, which is now much more like an Ada compiler (for a very small subset of the Ada language).

    Until yesterday, in a HAC program, integer values were silently converted to floating-point values whenever there was an opportunity to do so: passing a value as parameter, an arithmetic operator, assigning to a variable, returning a value. This is called an implicit type conversion or coercion.

    A significant portion of bugs in software - and a significant portion of time lost to stabilize software projects - are due to type promotion and type coercion (unless Ada is used of course).

    When C, Pascal or early script languages like S (the model for R) were out in the 1970's, programs were small because computers were limited and those kind of silent type conversions looked like a cool feature. When Ada was designed in the late 1970's, there was already much more experience in large software projects and implicit type conversion was correctly spotted as a significant source of bugs, so the designers of the Ada language decided that implicit type conversions would not be supported.
    Fast forward to 2020: projects are even much larger and complex, so every source of dumb bugs should be avoided.

    The reason implicit type conversion was also in HAC is that HAC originated from a Pascal compiler, morphed into Co-Pascal, then SmallAda. Some "Pascal-isms" remained in SmallAda, and we are removing them progressively.

    Now, since revision 111 (get it on SourceForge or GitHub), it's over! We've added a specific error message for those cases, since many people who are used to other languages could be disturbed by the absence of int-to-float type coercion. 

    HAC.Parser code (click to enlarge)

    Error message as appearing in the LEA editor

    As usual, feedback about HAC is welcome.

    HAC - new Mandelbrot demo

    12 April 2020 at 18:15
    Work is ongoing on HAC. Many changes are invisible to the user, or are related to improvements in the error messages. But there are some new features. For instance, constants can now have any type, and there are explicit type conversions from Integer to Real (the floating-point type) and vice-versa.

    The number of tests and demos is increasing. Notably, we've added a much needed Mandelbrot set demo. What would be HAC without some fun demos?

    From the LEA editor - click to enlarge

    From the command line with HAX - click to enlarge
    HAC is available on SourceForge and GitHub.

    HAC - compiler object instead of global data

    23 April 2020 at 23:38
    The HAC sources become more civilized, with clearer identifiers.
    There were dozens of global variables with obscure names which are now fields in a Compiler_Data object type.
    Concretely, the SmallAda sources (in Pascal) contained lots of variables like:
        ATAB      : array [1..AMAX] of ATABEntry ; (* array table          *)
        BTAB      : array [1..BMAX] of BTABEntry ; (* block-table          *)
        CODE      : array [0..CDMAX] of ORDER ;    (* object code table    *)
        EntryTAB  : array [0..EntryMax] of INDEX ; (* Entry Table          *)
        FAT       : FilDescr ;                     (* file i/o table       *)
        FCTAB     : array [1..C2MAX] of REAL ;     (* Float constant table *)
        STAB      : array [0..SMAX] of CHAR ;      (* string table         *)
        TAB       : array [0..TMAX] of TABEntry ;  (* identifier table     *)
        (*--- indicies to compiler tables  ---*)
        A      : integer ;   (* ---> index to ATAB     *)
        B      : integer ;   (* ---> index to BTAB     *)
        C1     : integer ;   (* ---> index to FCTAB    *)
        C2     : integer ;   (* ---> index to FCTAB    *)
        SX     : integer ;   (* ---> index to STAB     *)
        T      : integer ;   (* ---> index to TAB      *)
    So, the "archaeology" job was to understand what those variables mean, rename them, then encapsulate them in the Compiler_Data record.
    Now you find in HAC.Compiler:
      type Compiler_Data is record
        --  Compiler tables
        Arrays_Table            : Arrays_Table_Type;
        Blocks_Table            : Blocks_Table_Type;
        Display                 : Display_Type;
        Entries_Table           : Entries_Table_Type;
        File_IO_Table           : FilDescr;
        Float_Constants_Table   : Float_Constants_Table_Type;
        IdTab                   : Identifier_Table_Type;
        Strings_Table           : Strings_Table_Type;
        Tasks_Definitions_Table : Tasks_Definitions_Table_Type;
        --  Indices to compiler tables
        Arrays_Count            : Natural;
        Blocks_Count            : Natural;
        Entries_Count           : Natural;
        Float_Constants_Count   : Natural;
        RNum_Index              : Natural;
        Id_Count                : Natural;
      end record;
    Additionally, the removal of global variables opens the door for parallel compilation with HAC.
    A compilation job can be as simple as:
      CD : Compiler_Data;
        Open (f, In_File, name);
        CD.Line_Count:= 0;
        Set_Source_Stream (CD, Stream(f), name);
        Compile (CD);
        Close (f);
    You have a fully functional example in the hax.adb file, which is the command-line compiler and VM interpreter tool in the HAC project. 

    HAC - debug information

    24 April 2020 at 09:09
    We have now replaced the Virtual Machine instruction K_Hightlight_Source, which used to be emitted on each Ada statement in order to keep track of the source code line when the interpreter is running, by proper debug information. There are two advantages:
    • The object code if not polluted by instructions that do nothing for the program's purpose.
    • Source code tracking occur naturally on any place where object code is emitted (expressions, initialization code, etc.).
    Here is an example.
    The source code:
    with HAC_Pack;  use HAC_Pack;
    procedure Outer is
      x : Integer;

      procedure Inner is
        y : Integer := x;
        Put (y);

      x:= 123;
    The compiled object code, "before":
    Position   : Opcode                           X (Level)  Y (Address / Value)
              0: K_LOAD_ADDRESS                   2          5
              1: K_PUSH_VALUE                     1          5
              2: K_STORE                          0          0
              3: K_HIGHLIGHT_SOURCE               0          9 ... Source line 9
              4: K_SET_CURRENT_FILE_POINTER       0          0
              5: K_PUSH_VALUE                     2          5
              6: K_WRITE_1                        0          1
              7: K_EXIT_CALL                      0          0
              8: K_HIGHLIGHT_SOURCE               0         13 ... Source line 13
              9: K_LOAD_ADDRESS                   1          5
             10: K_LITERAL                        0        123
             11: K_STORE                          0          0
             12: K_HIGHLIGHT_SOURCE               0         14 ... Source line 14
             13: K_MARK_STACK                     0         44
             14: K_CALL                           0          4
             15: K_HALT_INTERPRETER               0          0
    The compiled object code, "after":
    Position   : Opcode                         Lvl X Addr/Val Y;      Approx. source location
              0: K_LOAD_ADDRESS                     2          5;           7  Inner       
              1: K_PUSH_VALUE                       1          5;           7  Inner       
              2: K_STORE                            0          0;           7  Inner       
              3: K_SET_CURRENT_FILE_POINTER         0          0;           9  Inner       
              4: K_PUSH_VALUE                       2          5;           9  Inner       
              5: K_WRITE_1                          0          1;           9  Inner       
              6: K_EXIT_CALL                        0          0;          12  Outer       
              7: K_LOAD_ADDRESS                     1          5;          13  Outer       
              8: K_LITERAL                          0        123;          13  Outer       
              9: K_STORE                            0          0;          13  Outer       
             10: K_MARK_STACK                       0         44;          14  Outer       
             11: K_CALL                             0          4;          14  Outer       
             12: K_HALT_INTERPRETER                 0          0;          15  [-- Nowhere --]
    The latest version of HAC is available at SourceForge and at GitHub

    HAC v.0.05 - variable-sized strings

    7 May 2020 at 16:24
    Lazy copy-paste from the announcement on comp.lang.ada:

    HAC (HAC Ada Compiler) is available on two open-source development sites:

    HAC is a small, open-source Ada compiler, covering a subset of
    the Ada language. There are chances you bump quickly into limitations.
    The documentation is more or less non-existent, but a glimpse into the
    file hac_pack.ads and some experimentation could be helpful.
    The time spent by HAC for compiling is rather short, so some users
    won't notice it even happens . This is an advantage for people who
    don't know what a compiler is, but could be interested in programming
    in Ada.

    The latest additions are:

    - type VString (variable-size string), with concatenation ("&"
    operator) including concatenation with numeric types (their
    image), comparison operators, Element, Length, Slice, Index,
    "*", Trim, Image, Integer_Value, Float_Value functions;
    Get_Line, Put, Put_Line subprograms for VString
    - Argument_Count, Argument (the latter returns a VString)
    - Get_Env, Set_Env, Shell_Execute system subprograms

    HAC programs are real Ada programs, they can be built by a "serious"
    Ada compiler, through the HAC_Pack compatibility package.
    See the exm/hac_exm.gpr and test/hac_test.gpr project files
    for the GNAT compiler.

    To build HAC itself for the command-line, all you need (with GNAT) is
    to run "gprbuild -P hac".
    Then you get the executable hax[.exe].
    The command "hax" alone will show you basic help.

    HAX: command-line compilation and execution for HAC (HAC Ada Compiler)
    Compiler version: 0.05 dated 06-May-2020.
    URL: http://sf.net/projects/hacadacompiler/

    Usage: hax [options] main.adb [command-line parameters for main]

    Options: -h : this help
    -v, v1 : verbose
    -v2 : very verbose
    -a : assembler output
    -d : dump compiler information


    Additional note: there are a few demos related to VString's (in the exm folder):

    • string_demo.adb (strings)
    • env.adb (environment variables)
    • arguments.adb (command-line arguments)
    • shell.adb (example of shell_execute)

    HAC - enumeration types

    8 May 2020 at 19:33
    Today we've experimented writing a script-like program with HAC. The purpose of the program is to run a bunch of demos in a portable way (in the sense: Windows-vs.-Linux-agnostic). The first surprise was that functions in HAC 0.05- could not return values of an enumerated type.
    The compiler said:
    10:44-46: bad result type for a function
    Shocking ! We've fixed that. This was less straightforward than hoped. The hope was that the parser's behavior was the same as for integers. See rev.174 for the nasty details.
    Additionally, we've fixed a bug, also originating from the SmallAda times at least, about the size of a variable of an enumerated type. Now that the compiler has been improved, the script-like program runs seamlessly, fulfilling three purposes at the same time:
    1. Testing HAC a bit more.
    2. Doing something useful (an operating-system-agnostic script).
    3. Showing an example of what can be done with HAC (esp. the recently added VString's and related functions.
    So, here is a glimpse on the pseudo-script program in question.

    Click to enlarge screenshot

    The program (and all the rest: full sources for HAC, tests and demos) is located on those two places:

    LEA v.0.70 - console input

    10 May 2020 at 18:18
    Here is a new functionality of LEA: console input.
    That is, when a program is run through the HAC compiler-and-interpreter,
    the Get, Get_Immediate and Get_Line are now getting something from the user.
    Here is a screenshot as an example:

    Click to enlarge
    You could ask: but does it work on a terminal?
    Answer: of course: it runs on a terminal too, with the HAX command (see the HAC project).

    LEA (and potentially any non-console software) benefits from an abstracted console I/O interface in HAC. But the normal way is a real console.
    You could ask now: but but but... it runs only on Windows, right?
    Not at all! It runs on all platforms where or for which you can
    run the GNAT compiler (Linuxes, *BSD, MacOS, ...) plus those
    supported by other Ada compilers, in order to build the HAX executable.
    Here is a screenshot from Ubuntu:

    The demo program is reproduced here:

        with HAC_Pack;  use HAC_Pack;

    procedure Hellos is
    s : VString;
    Put ("Enter your text (empty => quit)");
    for n in 1 .. 10 loop
    Get_Line (s);
    exit when s = +"";
    Put ("You just typed : [" & s & "] - " & n & ". Next:");
    end loop;
    Here is a link to LEAhttps://l-e-a.sourceforge.io/.
    You can download a read-to-use Windows executable there.

    The LEA sources are available on the above site as well as on GitHub: https://github.com/zertovitch/lea .

    Furthermore, the sources for the HAC system are located at


    HAC - Text_IO

    14 May 2020 at 20:32
    Today we've completely reprogrammed the "Text_IO" part of HAC.

    This concerns the console I/O, but there was also in HAC's ancestor, SmallAda, a somewhat hidden embryo of a file handle system, with undefined, special global variables meant to represent a bunch of files. This unfinished hack is replaced by a simpler system that leverages the Ada run-time's files.
    Since the goal is to stay compatible with Ada as HAC grows, we have added a normal built-in type, File_Type, that can be local, be passed to subprograms and wrapped into arrays or records for instance.

    Currently, File_Type is not yet visible to the HAC programmer, since the priority was to migrate and simplify the Virtual Machine's Text I/O instructions, to correct the few bugs brought by the migration, and to check everything. On the way, the numeric layout parameters were turned to be those of Ada.Text_IO, not anymore those of Pascal.

    The latest change is in revision #189, visible here or here.

    As a little fun, here is a little program reading itself like a "picture in a picture" recursion:
    *******[ HAX ]*******   Compiler version: 0.0531 dated 14-May-2020.
    *******[ HAX ]******* Caution: HAC is not a real Ada compiler. Type "hax" for license.
    . . . .[ HAX ]. . . . Compiling from file: echo.adb
    . . . .[ HAX ]. . . . Compilation finished in 0.001297600 seconds.
    . . . .[ HAX ]. . . . Starting p-code VM interpreter...
    Type your messages ("STOP!" or Ctrl-Z to stop):
    This is the echo... [-- Example from command-line: hax echo.adb echo.txt]
    This is the echo... []
    This is the echo... [with HAC_Pack; use HAC_Pack;]
    This is the echo... []
    This is the echo... [procedure Echo is]
    This is the echo... [ s : VString;]
    This is the echo... [begin]
    This is the echo... [ Put_Line ("Type your messages (""STOP!"" or Ctrl-Z to stop):");]
    This is the echo... [ while not End_Of_File loop]
    This is the echo... [ Get_Line (s);]
    This is the echo... [ -- Exit door if program run from a console without Ctrl-Z :]
    This is the echo... [ exit when s = "STOP!";]
    This is the echo... [ Put_Line ("This is the echo... [" & s & ']');]
    This is the echo... [ end loop;]
    This is the echo... [end Echo;]
    -------[ HAX ]------- VM interpreter done after 0.002240100 seconds.

    HAC v.0.06 - Text File I/O

    19 May 2020 at 08:55
    Lazy copy-paste from the announcement on the newsgroup comp.lang.ada:

    HAC (HAC Ada Compiler) is available on two open-source development sites:

    HAC is a small, quick, open-source Ada compiler, covering a subset of
    the Ada language.
    Even though the HAC documentation is more or less non-existent, the good
    news is that you can use as a help Ada books and online documentation
    about Ada: HAC does not define a dialect of Ada, only a subset.
    A glimpse into the file "src/hac_pack.ads" gives you the currently
    available types and subprograms.

    The latest additions are:

    - v.0.06: Text File I/O around File_Type (example below)

    - v.0.05: type VString (variable-size string), with various operators
    and functions ("&", "*", comparison operators, Element, Length,
    Slice, Index, Trim, Image, Integer_Value, Float_Value functions);
    system functions (Argument_Count, Argument, Get_Env, Set_Env,

    HAC programs are real Ada programs, they can be built by a "serious"
    Ada compiler, through the HAC_Pack compatibility package.
    See the exm/hac_exm.gpr and test/hac_test.gpr project files
    for the GNAT compiler.

    HAC is itself programmed in Ada. To build HAC for the command-line,
    all you need (with GNAT) is to run "gprbuild -p -P hac".
    Then you get the executable hax[.exe].
    The command "hax" alone will show you basic help.

    HAX: command-line compilation and execution for HAC (HAC Ada Compiler)
    Compiler version: 0.06 dated 18-May-2020.
    URL: https://hacadacompiler.sourceforge.io/

    Usage: hax [options] main.adb [command-line parameters for main]

    Options: -h : this help
    -v, v1 : verbose
    -v2 : very verbose
    -a : assembler output
    -d : dump compiler information

    Gautier's Ada programming
    NB: follow the above link for a valid e-mail address
    PS: The example (exm/file_copy.adb):

    with HAC_Pack; use HAC_Pack;

    procedure File_Copy is
    s : VString;
    f1, f2 : File_Type;
    Open (f1, "file_copy.adb");
    Create (f2, "file_copy.txt");
    while not End_Of_File (f1) loop
    Get_Line (f1, s);
    Put_Line (f2, s);
    end loop;
    Close (f1);
    Close (f2);
    end File_Copy;

    Click to enlarge