Project Logs

Collapse

• Tests

  Andrey Kalmatskiy • 02/14/2025 at 23:58 • 0 comments

  Argentum got a special syntax to define tests right in the source files along with a code that needs to be tested, and a special mode of compilation, designed to support those tests.

  using json;
  using tests { assert }
  ...
  class MyClass { ... }
  fn myFn(s str) int { ... }
  
  test myFnTest (){                              //<-- test
     assert(myFn("Some input data") == 42);
     ...
  }
  
  log("application started {myFn("some real data")}");

  If launched as usual it completely skips tests in the source code and build the application itself.

  But if add a command line key `-T "my.*Test"`  it ignores main entry point and instead build an app containing all tests matching the given regexp.

  It also supports mocks and test-specific fns/classes.

  More details here: https://aglang.org/tests/

• Argentum's Hello World with SDL, OpenGL and SKIA

  Andrey Kalmatskiy • 02/05/2025 at 01:46 • 0 comments

  Argentum integrated with SDL2/SKIA (backed by OpenGL renderer) this allows to create portable GUI frameworks.

  Code example:

  using sys { Blob, log }
  using guiPlatform { Canvas, Paint, Rect, Font, Image }
  
  class MyApp {
      +guiPlatform_App {
          onStart() {
              font.fromName("Arial Bold");
              img.fromBlob(Blob.{ _.loadFile("sd.png") : log("Img sd.png not loaded") });
          }
          onPaint(c Canvas) {
              phase += 1s;
              c.clear(0xff_ffffffs);
              p = Paint;
              c.drawRect(Rect.setXYWH(50f, 50f, 100f, 100f), p.color(0xff_ff0000s));
              forRangeFStep(0f, 700f, 4f)`i
                  c.drawLine(i, 0f, 0f, 700f - i, p.color(0xff_008800s | (short(i) + phase)));
              c.drawSimpleText(48f, 16f, "Hello", font, 16f, p.color(0xff_004400s));
              c.drawImage(108f, 100f, img);
          }
          onKey(pressed bool, key short, shifts short) {
              pressed && key == keyEsc ? setMainObject(?MyApp)
          }
     }
     phase = 0s;
     font = Font;
     img = Image;
  }
  MyApp.run("Hello AG", 120) // Start GUI app with windows title and given FPS

  Result: 

  More details: https://aglang.org/gui-platform/

• Argentum got a two-way JSON support

  Andrey Kalmatskiy • 12/23/2024 at 04:48 • 0 comments

  Argentum got a JSON module with both Parser and Writer.

  Let's try Writer in action:

  We'll use the same classes as in JSON Parser example:

  class Point{
      x = 0f;
      y = 0f;
  } 
  class Polygon {
      name = "";
      points = Array(Point);
      isActive = false;
  }

   This function converts an array of Polygons into a JSON string:

  fn polygonsToJson(data Array(Polygon)) str {
      Writer.useTabs().arr {
          data.each `poly _.obj {
              _("name").str(poly.name);
              _("active").bool(poly.isActive);
              _("points").arr\poly.points.each `pt _.obj {
                  _("x").num(double(pt.x));
                  _("y").num(double(pt.y))
              }
          }
      }.toStr()
  }

  • As with parser, the JSON writer does not create any intermediate DOM-like data structures and as such has no memory and CPU overheads.
  • It can produce both compact and pretty-printed JSONs, having configurable indentations.
  • As with parser, the JSON-writing code has absolutely no syntax overhead - all it contains is field-name-to data mapping, data formatters and handlers of nested objects and arrays. No DSL could have more concise syntax.
  • Combining parser and writer we can produce feature-rich JSON-handling applications running at a speed of native code and enjoying safety of managed one.

• Argentum apps can parse JSONs

  Andrey Kalmatskiy • 12/02/2024 at 20:36 • 0 comments

  JSON module for Argentum programming language allows to parse JSONs directly in application data structures, skipping the creation of JSON DOM. This takes two times less memory and reduces the time overheads by three-folds. The usual alternative to DOM parsers is streaming SAX parser, that requires application to have cumbersome state machine to handle data. Argentum JSON module doesn't use it either.

  JSON Parsing in Argentum is simple and extremely effective.

  For example, if we have such data structures:

  class Polygon {
      name = "";
      points = Array(Point);
      isActive = false;
  }
  class Point{
      x = 0f;
      y = 0f;
  }

  ... and we want to read JSONs of this structure:

  [
      {
          "active": false,
          "name": "p1",
          "points": [
              {"x": 11, "y": 32},
              {"y": 23, "x": 12},
              {"x": -1, "y": 4}
          ]
      },
      {
          "points": [
              {"x": 10, "y": 0},
              {"x": 0, "y": 10},
              {"y": 0, "x": 0}
          ],
          "active": true,
          "name": "Corner"
      }
  ]

  ... we can do it with this function: 

  using json { Parser }
  fn readPolygonsFromJson(data str) Array(Polygon) {
      Array(Polygon).{
         json = Parser.init(data);
         json.getArr\_.append(Polygon)-> json.getObj `f
            f=="active" ? _.isActive := json.getBool(false) :
            f=="name"   ? _.name := json.getStr("") :
            f=="points" ? json.getArr\_.points.append(Point)-> json.getObj `f (
                f=="x" ? _.x := float(json.getNum(0.0)) :
                f=="y" ? _.y := float(json.getNum(0.0)));
         json.success() : log("parsing error {json.getErrorMessage()}{json.getErrorPos()?" at {_.offset}"}");
      }
   }

  As you can see this function contains just:

  • mapping JSON field names to Argentum class fields,
  • data conversions/validation,
  • creations objects of types we want
  • populating collections we want the way you want

  It also checks and handles all format errors. And it is all in just 12 lines of code. 

  Despite its size, this function handles all the edge cases:

  • If input JSON has an unexpected field, this field is skipped.
  • This code is tolerant to any order of fields in objects.
  • If some needed field is absent from JSON, the it uses default values or calls handlers.
  • If some field, root element or array item in the JSON is of an unexpected type, it handles this as well.
  • Since all parsing is performed in plain Argentum code, we can easily add validating/transforming/versioning logic without inventing template-driven or string-encoded DSLs.
  • This parser is extremely rigid and resilient, it validates its input against JSON standard, detects and reports all errors.

  Let's call this function for completeness:

  myPolygons = readPolygonsFromJson("
    [{
          "active": false,
          "name": "p1",
          "points": [ {"x": 11, "y": 32}, {"y": 23, "x": 12}, {"x": -1, "y": 4}]
      },{
          "points": [{"x": 10, "y": 0}, {"x": 0, "y": 10}, {"y": 0, "x": 0}],
          "active": true,
          "name": "Corner"
      }]
  ")

  Pretty high-level for a language that compiles to tiny standalone machine code executables and runs at the speed of C++?

  Details are here https://aglang.org/json-module/

• Argentum got a Web Playground

  Andrey Kalmatskiy • 02/05/2024 at 04:21 • 0 comments

  Now it's possible to try the Argentum programming language online.

  Playground allows to play with a number of pre-existing examples as well as start from scratch. It opens to the old good modify-compile-run-repeat game. Also it allows to go by the number of existing tutorials and try-on all the examples from the argentum website posts.

  All details and a link to the playground is here: https://aglang.org/playground/

  Happy hacking! (but please don't break my Raspberry Pi on which it all runs)

• Argentum on ARM-64 and Raspberry Pi

  Andrey Kalmatskiy • 01/20/2024 at 04:37 • 0 comments

  Argentum compiler and runtime library successfully ported to ARM-64.
  It builds code for ARM-64.
  All compiled demos work fine on ARM-64/Raspberry Pi with tiny memory footprint and little CPU consumption.

  There are many platforms ahead: ARM/Android, ARM/OSX, WASM, RISCV.

• Argentum apps can talk to the Internet

  Andrey Kalmatskiy • 01/13/2024 at 16:08 • 0 comments

  Argentum cURL bindings gives full support for reach http(s), ftp... functionality.

  using httpClient{ get, Response }
  
  ...
  
  get("https://google.com", app.&onFetched(r Response){
      log("Result code={r.status}: response size={r.body.capacity()}");
  })

  • All operations are performed asynchronously on a separate thread.
  • Multiple simultaneous queries share the same resources/DNS caches etc.
  • For ssh/https requests the system key-stores are used.
  • All operations are cancellable. Then the listener object dies, the operation cancels automatically.
  • The httpClient_Request object allows to customize requests by adding different verbs, request headers etc.
  • The httpClient_Response object allows to get access to response headers, status code, response body and all request data.

• Argentum got SQLite integration

  Andrey Kalmatskiy • 01/07/2024 at 01:00 • 0 comments

  Example:

  Sqlite.open("../demo/mydb.sqlite", xReadWrite) ?
  _.query("
     SELECT "id", "name", "avatar"
     FROM "table"
     LIMIT 0, 20
  ", xSimpleQuery)
  .execute() row {
     id = row.intAt(0);
     name = row.stringAt(1);
     ava = row.stringAt(2);
     log(`${id} ${name} ${ava}`);
  "))

   This prints, depending on the actual database content:

  1 Andy  0x4563
  2 Paula 0x2321 

  The SQLiteFfi argentum module has multiple feature not shown in the example:

  • Connection can be stored and reused for multiple queries.
  • Queries can have parameters of int, string, blob types.
  • Queries can be stored and executed multiple times, possibly with different parameters.
  • Queries and connections can be created on different threads and result->object mapping can be performed on one thread with passing the resulting objects to the business logic threads.
  • The sqliteFfi is a low level API, you can build any query execution strategies atop of it.

  Currently  sqliteFfi links the full database engine inside the application that uses it, but this can be easily switched to DLL/so if needed.

• Argentum got key-value containers

  Andrey Kalmatskiy • 12/31/2023 at 17:25 • 0 comments

  using sys { Map } 
  
  class Pt{            // A user-def class.
     x = 0;            // Its fields
     y = 0;
     call(ax, int, ay int) this { x:= ax; y := ay }  // One of constructors.
  }
  
  m = Map(String, Pt)        // Declare map with string keys and Pt values.
     ("Alpha", Pt(1, 2))     // Fill it with data.
     ("Bravo", Pt(-1, 42));
  
  log(
     m["Aplha"]                 // Access element by key.
        ? `Pt(${_.x}, ${_.y})`  // Check it and convert to string.
        : `Not found`);         // Handle if no such element.

  This will output: Pt(1, 2).

  Maps are not built-in entities in Argentum, in fact even Arrays are not built-in. They are all mere classes of standard library. And since all Argentum classes are extendable, you can always add arbitrary methods to arrays and maps.

  m.each() k v {
      log(`key: ${k}  x: ${v.x}  y: ${v.y}`);
  }

  In this example `each` is the ordinary method implemented for map class in one of `utils` modules.

  Any user type can be a key.

  Argentum:

  • supports user-defined hash-functions
  • caches the once-computed hash in the object header
  • provides built-in hash for strings and address-based hash for generic objects.

  Map class requires keys to be frozen objects. This prevents from common error in other languages then by modifying map keys a map can be brought to incoherent state.

  There are owning maps, maps of weak pointers and maps of shared pointers to immutable objects. So maps follow all Argentum rules of object composition, sharing and thread-safe handling - so no races, no crashes, no overheads. And topology aware copy operation supports map as well:

  m1 = @m;  // Makes a full deep copy of the map

  This code not only copies the map along with all its values (keys are shared since they are immutable) but also it handles cross-references between map elements preserving object graph topology. In other languages this operation requires peculiar hand-written code, while in Argentum it's automated.

  Internally Maps are implemented as flat, open addressed, 2^n grow, linear probe, robin hood hash-tables. So they are fast and not that much memory consuming.

• Argentum ported to Linux

  Andrey Kalmatskiy • 11/18/2023 at 04:10 • 0 comments

  Argentum ported to Linux and run (both compiler and the compiled demo) on SteamOS

  To run the Argentum Demo on Ubuntu/Debian:

  # Download package
  wget -O aglan_0.0-1_amd64.deb \
  https://github.com/karol11/argentum/releases/download/win-lin-demo-v0.0.12/aglan_0.0-1_amd64.deb
  # ...And install it
  sudo dpkg -i aglan_0.0-1_amd64.deb

  To run the Argentum Demo on Steam Deck (or Arch Linux), follow these steps: https://aglang.org/install-argentum-demo-on-the-steamdeck-arch-linux/

  Demo contains fully functional compiler, runtime, examples and build script.

View all 24 project logs