Go into Home Settings. On the second page, go to "Color Theme". Toggle it.

Congratulations! You've switched from light background to dark. I personally like the dark scheme better, and suggest you use it.

HOLY HECK. A new update! Well, let's try out what's new...

On update, I get... A lock screen. An... Unexpected change. I don't really understand why it was included.

Well, first of all, it seems out prayers of data persistence have been answered. We can now write/read data from notes and programs programmatically! This really opens up a lot of frontiers if you think about it.

Notes is a weird variable. For instance, to get the names of all notes in the system, you have to copy Notes to another variable. No copies are involved if you just want the contents of all notes in the system, however!

Also, why are newlines scrubbed out when reading/writing?? They are kind of important. EDIT: Scrubbing doesn't happen in programs for some reason. Okay.

I'm kind of sad text formatting is lost when doing stuff with notes, but eh. Whatever.

The other new variables are super nice as well. Could be useful.

I can't get #cas/#end to work yet. I'll figure it out soon, I bet.

Also, regarding the conn kit: It does look a lot better. That's nice.

EDIT: Creating a new program via Programs crashes, it looks like. I'm using the emulator to test, though, so that might be why.

Can you have type parameters of a rank higher than 1? That always bugged me in Java.

I'm not sure. I'll have to get back to you on that one.

Anyways, My GitHub now has a wiki. There's already a getting started guide there, and soon I will be adding Source programming tutorials, specifications, and examples there. Check it out!

Right now, I'm working on developing a standard set of functions that all Source platforms get. HPPL specific ones are next.

To see how Source stuff is being divided up into packages, just go on over to https://docs.google.com/document/d/1Pe0HS0z0SAxyUH6f4UgXTKe88uxG5tcs7CyMtHha1ho/edit?usp=sharing !

I've also been working on Source bytecode optimization. It's going well.

I did a little work on parameterized types today. You use square brackets.



function test[K](a as list[K]) as K {
   return a[1]
}


@export
function main(a as list[int]) as int {
   return test(a)
}


Here, you can see two things: First, the list data type can have a type parameter; this indicates the type that can go into it or come out of it. Second, your own functions can specify type parameters, which are respected by the compiler.


EDIT: here's another example of parameters:



function do[A as int,B as int](a as A,b as B) as A {
return a+b
}


@export
function main[E as int](c as E,d as E) as E {
return do(c,d)
}


Multiple dispatch?

Source uses static dispatch, but yes, it does dispatch now.

Anyways, I've been working for HPPL drawing emulation in SourceBox. It's limited, but for now you can run this program in both the Prime and on your PC:

import prime.draw
import prime.io

@export
function main() {
   local a = [rgb(255,0,0),rgb(0,255,0),rgb(0,0,255),rgb(255,0,255),rgb(0,255,255),rgb(255,255,0)]
   screen.clear()
   screen.drawString("Press any key to begin.",20,10)
   waitForInput()
   local i = list.start
   while not isKeyDown(key.esc) {
      screen.fill(a[i] as int)
      screen.drawString("Source",125,40,7)
      wait(.5)

      if a[i]==a.last() {
         i = list.start
      } else {
         i+=1
      }
   }
   msgbox("Source. It's a programming language.")
}


I'm guessing the FFI is not going to be platform independent. Am I sensing compile-time code selection?

Yes, the @lang strings are platform-dependant, as well as @native. However, I plan on making a few @langs that are independent, such as ones for Source internal bytecode.

Basically, there is a bytecode operation called NATIVE which contains the @lang string. The platform assembles this operation however it wishes; in this case, the HPPL platform takes @lang=hppl blocks and inserts the contents directly into the HPPL output.


Moving on...


Today, I have for you more progress! We now have function overloading. Now you can have two functions with the same name and different arguments, like so:



@export
function overloadTest() {
print(func())
print(func("an argument"));
}


function func() {
return "Got no arguments!"
}


function func(a) {
return "Got "~a
}


Overloading via data type will be supported soon. Right now, however, I have made directive-based overloading, too.


So, in SourceBox, you have an output panel where calling print is like the standard println. Well, what if you want a newline-less print? Well, in SourceBox, there are two versions of print. They both take 1 argument, but one of them is tagged with the @append directive. Because of this fact, you can target the print-like one instead of the println-like one as so:



@main
function printTest() {
print("This ends with a newline.")
@append print("This one ")
@append print("does not.")
}


If you tag your function call with a directive, it will try to match the directives up between functions. This way, you can have a very fine way to control function call overloading.