Archive
Smart-Pascal: A brave new world, 2022 is here
Trying to explain what Smart Mobile Studio does and the impact it can have on your development cycle is very hard. The market is rampant with superficial frameworks that promises you the world, and investors have been taken for a ride by hyped up, one-click “app makers” more than once.
I can imagine that being an investor is a bit like panning for gold. Things that glitter the most often turn out to be worthless – yet fortunes may hide beneath unpolished and rugged surfaces.
Software will disrupt most traditional industries in the next 5-10 years.
Uber is just a software tool, they don’t own any cars, yet they are now the
biggest taxi company in the world. -Source: R.M.Goldman, Ph.d
So I had enough. Instead of trying to tell people what I can do, I decided I’m going to show them instead. As the american’s say: “talk is cheap”. And a working demonstration is worth a thousand words.
Care to back that up with something?
A couple of weeks ago I published a video on YouTube of our Smart Pascal based desktop booting up in VMWare. The Amiga forums went off the chart!
For those that havent followed my blog or know nothing about the desktop I’m talking about, here is a short summary of the events so far:
Smart Mobile Studio is a compiler that takes pascal, like that made popular in Delphi or Lazarus, and compiles it JavaScript instead of machine-code.
This product has shipped with an example of a desktop for years (called “Quartex media desktop”). It was intended as an example of how you could write a front-end for kiosk machines and embedded devices. Systems that could use a touch screen as the interface between customer and software.
You have probably seen those info booths in museums, universities and libraries? Or the ticket machines in subways, train-stations or even your local car-wash? All of those are embedded systems. And up until recently these have been small and expensive computers for running Windows applications in full-screen. Applications which in turn talk to a server or local database.
Smart Mobile Studio is able to deliver the exact same (and more) for a fraction of the price. A company in Oslo replaced their $300 per-board unit – with off the shelves $35 Raspberry Pi mini-computers. They then used Smart Pascal to write their client software and ran it in a fullscreen-browser. The Linux distribution was changed to boot straight into Firefox in full-screen. No Linux desktop, just a web display.
The result? They were able to cut production cost by $265 per unit.
Right, back to the desktop. I mentioned the Amiga community. This is a community of coders and gamers that grew up with the old Commodore machines back in the 80s and 90s. A new Amiga is now on the way (just took 20+ years) – and the look and feel of the new operating-system, Amiga OS 4.1, is the look and feel I have used in The Smart Desktop environment. First of all because I grew up on these machines myself, and secondly because the architecture of that system was extremely cost-effective. We are talking about a system that delivered pre-emptive multitasking in as little as 512Kb of memory (!). So this is my “ode to OS 4” if you will.
And the desktop has caused quite a stir both in the Delphi community, cloud community and retro community alike. Why? Because it shows some of the potential cloud technology can give you. Potential that has been under their nose all this time.
And even more important: it demonstrate how productive you can be in Smart Pascal. The operating system itself, both visual and non-visual parts, was put together in my spare time over 3 weeks. Had I been able to work on it daily (as a normal job) I would have knocked it out in a week.
A desktop as a project type
All programming languages have project types. If you open up Delphi and click “new” you are greeted with a rich menu of different projects you can make. From low-level DLL files to desktop applications or database servers. Delphi has it all.
Delphi offers a wide range of projects types you can create
The same is true for visual studio. You click “new solution” and can pick from a wide range of different projects. Web projects, servers, desktop applications and services.
Smart Pascal is the only system where you click “new project” and there is a type called “Smart desktop” and “Smart desktop application”. In other words, the power to create a full desktop is now an integrated part of Smart Pascal.
And the desktop is unique to you. You get to shape it, brand it and make it your own!
Let us take a practical example
Imagine a developer given the task to move the company’s aging invoice and credit system from the Windows desktop – to a purely web-based environment.
The application itself is large and complex, littered with legacy code and “quick fixes” going back decades. Updating such a project is itself a monumental task – but having to first implement concepts like what a window is, tasks, user space, cloud storage, security endpoints, look and feel, back-end services and database connectivity; all of that before you even begin porting the invoice system itself ? The cost is astronomical.
And it happens every single day!
In Smart Pascal, the same developer would begin by clicking “new project” and selecting “Smart desktop”. This gives him a complete desktop environment that is unique to his project and company.
A desktop that he or she can shape, adjust, alter and adapt according to the need of his employer. Things like file-type recognition, storage, getting that database – all of these things are taken care of already. The developer can focus on his task, namely to deliver a modern implementation of their invoice and credit software – not waste months trying to force JavaScript frameworks do things they simply lack the depth to deliver.
Once the desktop has the look and feel in order, he would have to make a simple choice:
- Should the whole desktop represent the invoice system or ..
- Should the invoice system be implemented as a secondary application running on the desktop?
If it’s a large and dedicated system where the users have no need for other programs running, then implementing the invoice system inside the desktop itself is the way to go.
If however the customer would like to expand the system later, perhaps add team management, third-party web-services or open-office like productivity (a unified intranet if you like) – then the second option makes more sense.
On the brink of a revolution
The developer of 2022 is not limited to the desktop. He is not restricted to a particular operating system or chip-set. Fact is, cloud has already reduced these to a matter of preference. There is no strategic advantage of using Windows over Linux when it comes to cloud software.
Where a traditional developer write and implement a solution for a particular system (for instance Microsoft Windows, Apple OS X or Linux) – cloud developers deliver whole eco systems; constellations of software constructed from many parts, both micro-services developed in-house but also services from others; like Amazon or Azure.
All these parts co-operate and can be combined through established end-point standards, much like how components are used in Delphi or Visual Studio today.
The Smart Desktop, codename “Amibian.js”
Access to products written in Smart is through the browser, or sometimes through a “paper thin” native host (Cordova Phonegap, Delphi and C/C++) that expose system level functionality. These hosts wrap your application in a native, executable container ready for Appstore or Google Play.
Now the visual content is typically the same, and is only adapted for a particular device. The real work is divided between the client (which is now very much capable) and your server back-end.
So people still write code in 2022, but the software behaves differently and is designed to function as a group (cluster). And this requires a shift in the way we think.
Above: One of my asm.js prototype compilers. Lets just say it runs fast!
Scaling a solution from processing 100 invoices a minute to handling 100.000 invoices a minute – is no longer a matter of code, but of architecture. This is where the traditional, native only approach to software comes up short, while more flexible approaches like node.js is infinitely more capable.
What has emerged up until now is just the tip of the ice-berg.
Over the next five to eight years, everything is going to change. And the changes will be irrevocable and permanent.
The Smart Desktop back-end running as a system service on a Raspberry PI
As the Americans say, talk is cheap – and I’m done talking. I will do this with you, or without you. Either way it’s happening.
Nightly-build of the desktop can be tested here: http://quartexhq.myasustor.com/
Smart Desktop: Inter frame communication
What is a process in a web desktop environment? Been thinking a bit about this, and it’s actually not that easy to hang the reality of an external script or website running in a frame as a solid “concept” (I use the word entity in my research notes). Visually it appears as a secondary, isolated web application – but ultimately (or technically) it’s just another web object with its own rendering context.
What I’m talking about is programs. Amibian.js or Smart desktop can already run a wealth of applications – which ultimately are just external or internal web-pages (a very simple term in some cases, but it will have to do). But when you want complex behavior from an eco-system, you must also provide an equally complex means of communication.
And this brings me neatly to the heart of todays task – namely how the desktop can talk to running web-applications and visa versa. And there are ultimately only two real options to choose from here: pure client, or client-server.
Unlike other embedded / web desktops I want to do as much as possible client-side. It would take me five minutes to implement message dispatching if I did this server-side, but the less dependent we are on a server – the more flexible amibian.js will be in terms of integration.
The first Desktop-Application type running in the desktop! And its aware that it is running under Amibian. This frame/host awareness helps establish parent/child relationship
Turns out that the browser has an API for this. A message API that allows a main website to talk with other websites embedded in IFrames. Which is just what we need.
But its very crude and not as straight forward as you may think. You have commands like postMessage() and then you can set up an event-handler that fires whenever something comes through. But you also have security measures to think about. What if you interface with a web-application designed to kill the system? Without the safety of an abstraction layer that would indeed be a very easy hack.
The Smart message API
This has been in the RTL for quite some time but I havent really used it for much. I had one demo a couple of years back that used the message-api to handle off-screen rendering in a separate IFrame (sort of poor mans thread), but that was it.
Well, time to update and bring it into 2017! So I give you the new and improved inter-frame, inter-window and inter-domain message framework! (ta da!)
It should be self-evident how to use it, but a little context wont hurt:
- You inherit from TW3MessageData and implement whatever data-fields you need
- You send messages using the w3_SendMessage() method
- You broadcast (i.e send the message to all frames and windows listening) messages using the w3_broadcastMessage method
But here comes the twist, because I hate having to write a bunch of if/then/else switches for messages. So instead I created a simple subscription system! Super small yet very efficient!
In other words, you inform the system which messages you support, which then becomes your subscription. Whenever the local dispatcher encounters that particular message type – it will forward the message object to you.
Here is the code. Notice the helper functions that deals with finding the current domain and so on – this will be handy when establishing a parent/child relationship.
Also note: you are expected to inherit from these classes and shape them to your message types. I have implemented the bare-bones that mimic’s Windows message API. And yes, please google inter-frame communication while testing this.
unit SmartCL.Messages;
interface
uses
w3c.dom,
System.Types,
System.Time,
System.JSON,
Smartcl.Time,
SmartCL.System;
const
CNT_QTX_MESSAGES_BASEID = 1000;
type
TW3MessageData = class;
TW3CustomMsgPort = class;
TW3OwnedMsgPort = class;
TW3MsgPort = class;
TW3MainMessagePort = class;
TW3MessageSubscription = class;
TW3MessageSubCallback = procedure (Message: TW3MessageData);
TW3MsgPortMessageEvent = procedure (Sender: TObject; EventObj: JMessageEvent);
TW3MsgPortErrorEvent = procedure (Sender: TObject; EventObj: JDOMError);
(* The TW3MessageData represents the actual message-data which is sent
internally by the system. Notice that it inherits from JObject, which
means it supports 1:1 mapping from JSON.
This is why Deserialize is a member, and Serialize is a class member. *)
TW3MessageData = class(JObject)
public
property ID: Integer;
property Source: String;
property Data: String;
function Deserialize: string;
class function Serialize(const ObjText: string): TW3MessageData;
constructor Create;
end;
(* A "mesage port" is a wrapper around the [obj]->Window[]->OnMessage
event and [obj]->Window[]->PostMessage API.
Where [obj] can be either the main window, or an embedded
IFrame->contentWindow. This base-class implements the generic behavior.
You must inherit or use a decendant class if you dont know exactly what
you are doing! *)
TW3CustomMsgPort = Class(TObject)
private
FWindow: THandle;
protected
procedure Releasewindow;virtual;
procedure HandleMessageReceived(eventObj: JMessageEvent);
procedure HandleError(eventObj: JDOMError);
public
Property Handle:THandle read FWindow;
Procedure PostMessage(msg:Variant;targetOrigin:String);virtual;
procedure BroadcastMessage(msg:Variant;targetOrigin:String);virtual;
Constructor Create(WND: THandle);virtual;
Destructor Destroy;Override;
published
property OnMessageReceived: TW3MsgPortMessageEvent;
Property OnError: TW3MsgPortErrorEvent;
end;
(* This is a baseclass for window-handles that already exist.
You are expected to provide that handle via the constructor *)
TW3OwnedMsgPort = Class(TW3CustomMsgPort)
end;
(* This message-port type is very different from both the
ad-hoc baseclass and "owned" variation above.
This one actually creates it's own IFrame instance, which
means it's a completely stand-alone entity which doesnt need an
existing window to dispatch and handle messages *)
TW3MsgPort = Class(TW3CustomMsgPort)
private
FFrame: THandle;
function AllocIFrame: THandle;
procedure ReleaseIFrame(aHandle: THandle);
protected
procedure ReleaseWindow; override;
public
constructor Create; reintroduce; virtual;
end;
(* This message port represent the "main" message port for any
application that includes this unit. It will connect to the main
window (deriving from the "owned" base class) and has a custom
message-handler which dispatches messages to any subscribers *)
TW3MainMessagePort = Class(TW3OwnedMsgPort)
protected
procedure HandleMessage(Sender: TObject; EventObj: JMessageEvent);
public
constructor Create(WND: THandle); override;
end;
(* Information about registered subscriptions *)
TW3SubscriptionInfo = Record
MSGID: integer;
Callback: TW3MessageSubCallback;
end;
(* A message subscription is an object that allows you to install
X number of event-handlers for messages you want to recieve. Its
important to note that all subscribers to a message will get the
same message -- there is no blocking or ownership concepts
involved. This system is a huge improvement over the older WinAPI *)
TW3MessageSubscription = class(TObject)
private
FObjects: Array of TW3SubscriptionInfo;
public
function ValidateMessageSource(FromURL: string): boolean; virtual;
function SubscribesToMessage(const MSGID: integer): boolean; virtual;
procedure Dispatch(const Message: TW3MessageData); virtual;
function Subscribe(const MSGID: integer; const CB: TW3MessageSubCallback): THandle;
procedure Unsubscribe(const Handle: THandle);
Constructor Create; virtual;
Destructor Destroy; override;
end;
(* Helper functions which simplify message handling *)
//function W3_MakeMsgData:TW3MessageData;
procedure W3_PostMessage(const msgValue: TW3MessageData);
procedure W3_BroadcastMessage(const msgValue: TW3MessageData);
(* Audience returns true if a message-ID have any
subscriptions assigned to it *)
function W3_Audience(msgId: integer): boolean;
(* This returns true if the current smart application is embedded in a frame.
That can be handy to know when establishing parent/child relationships
between main-application and child "programs" running in frames *)
function AppRunningInFrame: boolean;
function GetUrlLocation: string;
function GetDomainFromUrl(URL: string; const IncludeSubDomain: boolean): string;
implementation
uses SmartCL.System;
var
_mainport: TW3MainMessagePort = NIL;
_subscribers: Array of TW3MessageSubscription;
function AppRunningInFrame: boolean;
var
LMyFrame: THandle;
begin
// window.frameElement Returns the element (such as <iframe> or <object>)
// in which the window is embedded, or null if the window is top-level.
try
// Note: attempting to read frameElement will throw a SecurityError
// exception in cross-origin iframes. It should just return null,
// but not all browsers play by the rules -- hence the try/catch
asm
@LMyFrame = window.frameElement;
end;
except
on e: exception do
exit;
end;
result := not (LMyFrame);
end;
function GetUrlLocation: string;
begin
asm
@result = window.location.hostname;
end;
end;
function GetDomainFromUrl(Url: string; const IncludeSubDomain: boolean): string;
begin
url := Url.trim();
if url.length < 1 then
begin
asm
@Url = window.location.hostname;
end;
end;
asm
@url = (@url).replace("/(https?:\/\/)?(www.)?/i", '');
if (!@IncludeSubDomain) {
@url = (@url).split('.');
@url = (@url).slice((@url).length - 2).join('.');
}
if ((@url).indexOf('/') !== -1) {
@result = (@url).split('/')[0];
} else {
@result = @url;
}
end;
end;
//#############################################################################
//
//#############################################################################
procedure QTXDefaultMessageHandler(sender:TObject;EventObj:JMessageEvent);
var
x: Integer;
mItem: TW3MessageSubscription;
mData: TW3MessageData;
begin
mData := TW3MessageData.Serialize(EventObj.Data);
//mData := new TW3MessageData();
//mData.Serialize(EventObj.Data);
for x:=0 to _subscribers.count-1 do
Begin
mItem := _subscribers[x];
// Check that the message is subscribed to
if mItem.SubscribesToMessage(mData.ID) then
begin
// Make sure subscriber validates the caller-domain
if mItem.ValidateMessageSource( TVariant.AsString(EventObj.source) ) then
begin
(* We execute with a minor delay, allowing the browser to
exit the function before we dispatch our data *)
TW3Dispatch.Execute(procedure ()
begin
mItem.Dispatch(mData);
end, 10);
end;
end;
end;
end;
{ function W3_MakeMsgData: TW3MessageData;
begin
result := new TW3MessageData();
result.Source := "*";
end; }
function W3_GetMsgPort: TW3MainMessagePort;
begin
if _mainport = NIL then
_mainport := TW3MainMessagePort.Create(BrowserAPI.Window);
result := _mainport;
end;
procedure W3_PostMessage(const msgValue:TW3MessageData);
begin
if msgValue<>NIL then
W3_GetMsgPort().PostMessage(msgValue.Deserialize,msgValue.Source) else
raise exception.create('Postmessage failed, message object was NIL error');
end;
procedure W3_BroadcastMessage(const msgValue:TW3MessageData);
Begin
if msgValue<>NIL then
W3_GetMsgPort().BroadcastMessage(msgValue,msgValue.Source) else
raise exception.create('Broadcastmessage failed, message object was NIL error');
end;
function W3_Audience(msgId: Integer): boolean;
var
x: Integer;
mItem: TW3MessageSubscription;
begin
result:=False;
for x:=0 to _subscribers.count-1 do
Begin
mItem:=_subscribers[x];
result:=mItem.SubscribesToMessage(msgId);
if result then
break;
end;
end;
//#############################################################################
// TW3MainMessagePort
//#############################################################################
Constructor TW3MessageData.Create;
begin
self.Source:="*";
end;
function TW3MessageData.Deserialize: string;
begin
result := JSON.Stringify(self);
end;
class function TW3MessageData.Serialize(const ObjText: string): TW3MessageData;
begin
result := TW3MessageData(JSON.parse(ObjText));
end;
//#############################################################################
// TW3MainMessagePort
//#############################################################################
constructor TW3MainMessagePort.Create(WND: THandle);
begin
inherited Create(WND);
OnMessageReceived := QTXDefaultMessageHandler;
end;
procedure TW3MainMessagePort.HandleMessage(Sender: TObject; EventObj: JMessageEvent);
begin
QTXDefaultMessageHandler(self, eventObj);
end;
//#############################################################################
// TW3MessageSubscription
//#############################################################################
Constructor TW3MessageSubscription.Create;
begin
inherited Create;
_subscribers.add(self);
end;
Destructor TW3MessageSubscription.Destroy;
Begin
_subscribers.Remove(self);
inherited;
end;
function TW3MessageSubscription.Subscribe(const MSGID: integer; const CB: TW3MessageSubCallback): THandle;
var
LObj: TW3SubscriptionInfo;
begin
LObj.MSGID := MSGID;
LObj.Callback := @CB;
FObjects.add(LObj);
result := LObj;
end;
procedure TW3MessageSubscription.Unsubscribe(const Handle: THandle);
var
x: Integer;
begin
for x:=0 to FObjects.Count-1 do
begin
if variant(FObjects[x]) = Handle then
Begin
FObjects.delete(x,1);
break;
end;
end;
end;
function TW3MessageSubscription.ValidateMessageSource(FromURL: string): boolean;
begin
// by default we accept messages from anywhere
result := true;
end;
function TW3MessageSubscription.SubscribesToMessage(const MSGID: integer): boolean;
var
x: Integer;
begin
result:=False;
for x:=0 to FObjects.Count-1 do
Begin
if FObjects[x].MSGID = MSGID then
Begin
result:=true;
break;
end;
end;
end;
procedure TW3MessageSubscription.Dispatch(const Message:TW3MessageData);
var
x: Integer;
begin
for x:=0 to FObjects.Count-1 do
Begin
if FObjects[x].MSGID = Message.ID then
Begin
if assigned(FObjects[x].Callback) then
FObjects[x].Callback(Message);
break;
end;
end;
end;
//#############################################################################
// TW3MsgPort
//#############################################################################
Constructor TW3MsgPort.Create;
begin
FFrame:=allocIFrame;
if (FFrame) then
inherited Create(FFrame.contentWindow) else
Raise Exception.Create('Failed to create message-port error');
end;
procedure TW3MsgPort.ReleaseWindow;
Begin
ReleaseIFrame(FFrame);
FFrame:=unassigned;
Inherited;
end;
Procedure TW3MsgPort.ReleaseIFrame(aHandle:THandle);
begin
If (aHandle) then
Begin
asm
document.body.removeChild(@aHandle);
end;
end;
end;
function TW3MsgPort.AllocIFrame: THandle;
Begin
asm
@result = document.createElement('iframe');
end;
if (result) then
begin
/* if no style property is created, we provide that */
if not (result['style']) then
result['style'] := TVariant.createObject;
/* Set visible style to hidden */
result['style'].display := 'none';
asm
document.body.appendChild(@result);
end;
end;
end;
//#############################################################################
// TW3CustomMsgPort
//#############################################################################
Constructor TW3CustomMsgPort.Create(WND: THandle);
Begin
inherited Create;
FWindow := WND;
if (FWindow) then
begin
FWindow.addEventListener('message', @HandleMessageReceived, false);
FWindow.addEventListener('error', @HandleError, false);
end;
End;
Destructor TW3CustomMsgPort.Destroy;
begin
if (FWindow) then
begin
FWindow.removeEventListener('message', @HandleMessageReceived, false);
FWindow.removeEventListener('error', @HandleError, false);
ReleaseWindow;
end;
inherited;
end;
procedure TW3CustomMsgPort.HandleMessageReceived(eventObj:JMessageEvent);
Begin
if assigned(OnMessageReceived) then
OnMessageReceived(self,eventObj);
End;
procedure TW3CustomMsgPort.HandleError(eventObj:JDOMError);
Begin
if assigned(OnError) then
OnError(self,eventObj);
end;
procedure TW3CustomMsgPort.Releasewindow;
begin
FWindow := Unassigned;
end;
Procedure TW3CustomMsgPort.PostMessage(msg:Variant;targetOrigin:String);
begin
if (FWindow) then
FWindow.postMessage(msg,targetOrigin);
end;
// This will send a message to all frames
procedure TW3CustomMsgPort.BroadcastMessage(msg:Variant;targetOrigin:String);
var
x: Integer;
mLen: Integer;
begin
mLen := TVariant.AsInteger(browserAPI.Window.frames.length);
for x:=0 to mLen-1 do
begin
browserAPI.window.frames[x].postMessage(msg,targetOrigin);
end;
end;
finalization
begin
if assigned(_mainport) then
_mainport.free;
end;
end.
Amibian.js and the Narcissus hack
Wow, I must admit that I never really thought Amibian.js would become even remotely as popular as it has – yet people respond with incredible enthusiasm to our endeavour. I was just told that an article at Commodore USA mentioned us – that an exposure to 37000 readers. Add that to the roughly 40.000 people that subscribe to my feeds around the world and I must say: I hope I code something worthy of your time!
This is going to look and behave like the bomb when im done!
But there is a lot of stuff on the list before it’s even remotely finished. This is due to the fact that im not just juggling one codebase here – im juggling 5 separate yet interconnected codebases at the same time (!). First there is the Smart Mobile Studio RTL (run time library) which represents the foundation. This gives me object-oriented, fully inheritance driven visual controls. This have roughly 5 years of work behind it.
Still #1 after all these years
On top of that you have the actual visual controls, like buttons, scrollbars, lists, css3 effect engines, tweening, database storage and a ton of low-level stuff. The browser have no idea what a window is for example, let alone how it should look or respond to users. So every little piece has to be coded by someone. And well, that’s what I do.
Next you have the workbench and operating-system itself. What you know as Amibian.js, Smart Workbench or Quartex media desktop – take your pick, but it’s already a substantial codebase spanning some 40 units with thousands of lines of code. It is divided into two parts: the web front-end that you have all seen; and the node.js backend that is not yet made public.
And on top of that you have the external stuff. Quake III didn’t spontaneously self-assemble inside the desktop, someone had to do some coding and make the two interface. Same with all the other features you have.
The worst so far (as in damn hard to get right) is the Ace text editor. Ace by itself is super easy to work with – but you may have noticed that we have removed it’s scrollbars and replaced these with Amiga scrollbars instead? That is a formidable challenge it its own right.
Aced it! Kidnapping signals was a challenge
Whats on the menu this weekend?
I noticed that on Linux that text-selection was utterly messed up, so when you moved a window around – it would suddenly start selecting the title text of other elements around the desktop. This is actually a bug in the browser – not my code; but I still have to code around it. Which I have now done.
I also solved selection for the console window (or any “text” container. A window is made up of many parts and the content region can be inherited from and replaced), so that should now work fine regardless of browser and platforms. Ace theming also works, and the vertical scrollbar is responding as expected. Still need a few tweaks to move right, but that is easy stuff. The hard part is behind us thankfully.
Selection – works
Right now I’m working on ScummVM so that should be in place later today 🙂
Thats cool, but what motivates you?
Cult of Joy
Retro gaming is important, and we have to make it as easy for people to enjoy their retro gear without patent trolls ruining the fun. Im just so tired of how ruined the Amiga scene is by these (3 companies in particular).. thieves is the only word I can find that fits.
So fine! I will make my own. Come hell or high water. Free as a bird and untouchable.
So I have made some tools that will make it ridiculously easy for you to share, download and play your games online. Whenever you want, hosted where-ever you need and there is not a god damn thing people can do about it. When you realize how simple the hack is it will make you laugh. I came up with this ages ago and dubbed it Narcissus.
To understand the Narcissus hack, consider the following:
PNG is a lossless compression format, meaning that it doesn’t lose any information when compressed. It’s not like JPEG which scrambles the original and saves a faximile that tricks the eye. Nope, if you compress a PNG image you get the exact same out when you decode it (read: show it).
But who said we have to store pixels? Pixels are just bytes after all. In fact, why can’t we take a whole game disk or rom and store that inside a picture? Sure you can!
This tool is now built into Amibian.js
It’s amusing, I came up with this hack years ago. It has been a part of Smart Mobile Studio since the beginning.
You have to remember that retro games are super small compared to modern games. The average ADF file is what? 880kb or something like that? Well hold on to your hat buddy, because PNG can hold 64 megabyte of data! You can encode a decent Amiga hard disk image in 64 megabyte.
Can you guess what the picture on the right contains? This picture is actually ALL the Amiga rom files packed into a single image. Dont worry, I converted it to JPEG to mess up the data before uploading. But yes, you can now host not just the games as normal picture files, but also roms and whatever you like.
And the beauty of it – who the hell is going to find them? You can host them on Github, Google drive, Dropbox or right your blog — if you don’t have the encryption key the file is useless.
Snap, crackle and pop!
RSS Filesystem
You know RSS feeds right? If you sign up for a blog you automatically get a RSS feed. It’s basically just a list of your recent posts – perhaps with an extract from each article, a thumbnail picture and links to each post. RSS have been around for a decade or more. It’s a great way to keep track of news.
The second hack is that using the data-to-image-encoder you can store a whole read-only filesystem as a normal RSS feed. Always think outside the box!
Let’s say you have a game collection for your Amiga right? Lets say 200 games. Wouldnt it be nice to have all those games online? Just readily available regardless of where you may be? Without “you know who” sending you a nasty email?
Well, just encode your game as described above, include the data-picture in your WordPress post, and do that for each of your games. Since you can encrypt these images they will be worthless to others. But for you its a neat way of hosting all your games online for free (like WordPress or Blogger) and play them via Amibian or the patched UAE4Arm (ops, did I share that, sorry dirk *grin*) and you’re home free.
You know what’s really cool? For this part Amibian doesnt even need a server. So you can just save the Amibian.js html page on your phone and that’s all you need.
Drink up me hearties yo ho!
Smart Puppy: Smart pascal meets linux!
One of my absolute favorite operating-systems in the whole world has to be Puppy Linux. I discovered it just a few days ago and I have fallen completely in love with this thing. I can vaguely remember giving it a testdrive a few years back, but I didn’t know much about Linux in general so I didn’t understand what I it represented.
So if you are looking for a friendly, small, fast and easy to use Linux system – then Puppy is about as friendly as it gets. The Facebook user group with the same name is a warm and friendly place to be. Much like Delphi developer the Admin(s) take pride in keeping things orderly – and people who hang out there engage, care and help each other out.
Before you run out and download Puppy, which I hope you do later – please understand that Puppy is very different from Linux in general. You could almost say that it’s a whole alternative to mainstream Linux as we know it.
But, once you know about the differences then you are in for a treat! I will explain them in the article, so please be patient and take the time to digest.
Puppies hate fluff
One of the reasons I never converted wholesale to Linux (and yes I did try) – is that the average Linux distro is unbearable and unnecessary cryptic. For some reason Linux architects suffer from a terrible affliction, namely a shortage of characters. This sickness means that Linux don’t have enough characters for everyone, so programmers must use a maximum of five letters when naming their software. If coders ignore this shortage and blatantly name something directly or intuitively – then Richard Stallman and Lady Gaga will order a “drive-by pony tail cut” on the dude. And a Linux administrator without his pont-tail is finished (the nerd equivalent of flipping burgers at McDonalds).
Puppy Linux does contain it’s fair share of the classical Linux software (that goes without saying). But, the man behind this wonderful Linux flavour is also a level-headed, clever and resourceful man (or woman) – so he has thankfully broken with what can only be described as archaic thinking.
Puppy Linux is not exactly software impaired
So even with my minimal Linux experience I was able to navigate around the filesystem, locate documents (which here is called “Documents” and “My Documents” even). There is a whole bunch of these tiny differences, small things that makes all the difference. From the way he (or she) has named things – to where things are stored and placed.
And it’s so small! The basic install is less than 300 megabytes in size (!) Yes you read that right. The generic Puppy Linux installation with desktop and a few popular applications is less than 300 megabytes.
In my case I can have a fully loaded development studio, featuring GCC, FPC (freepascal), Lazarus IDE, CodeBlocks IDE, KDevelop IDE, Anjunta developer studio – and last but never least Smart Mobile Studio on a 2 gigabyte USB stick (!) I don’t think you can even get USB sticks that small any more (?) The smallest I got is 32 gigabyte and the largest is 256 gigabyte.
But before we go on with the wonders of Puppy Linux – lets look at what Linux did wrong. Why is Linux even to this day considered hard to use? Or to put it another way: what has Windows and OS X done right to be considered easier to use yet capable of the same (and often more) ?
Naming, what Linux did wrong
One of the tenants of professional programming, is to ensure that classes, members and functions have meaningful names. There was a time when you would get away with single character class, variable and method names — but that wont fly in 2017. Your Q&A department would have you for breakfast if you checked in code like that. Classes, name-spacing and packages should be descriptive. End of story.
The reason this has become an almost sacred law, should be obvious: it may not be you that maintains the software 5, 10 or 15 years down the road. A piece of code should always be written in such a way that it can be understood and thus maintained by others within a reasonable time-frame (which also means plenty of comments and good documentation). This is not a matter of preference, but of time and money. And when you pay out salaries these factors are one and the same.
So naming elements of software in 2017 has a lot of criteria attached to it. The most obvious so far being:
- Always name things clearly because that
- ensures ease of use
- simplifies maintenance
- removes doubt as to “what is what”
- less user-mistakes
- The less mistakes, either in understanding something or using something, the less money a business throws out the window. Money that could be spent paying you to make something cool instead (or fix bugs that are critical).
- The less user-mistakes caused by customers, the more your service department can focus on quality of service. When a company starts it usually have outstanding support, but as it grows their service-desk slowly become robots.
- The easier and more intuitive a system is, the more users it will attract. If people can pick something up and just naturally figure out how things work, then statistics show that they most likely will continue using it through thick and thin.
Right. With these rules in mind – what happens if you take them but apply them to Linux instead? Not Linux code or libraries or stuff like that, but Linux the user-experience from top to bottom?
And don’t get me wrong, I think Linux is awesome so this is not an attack on Linux; I’m simply pointing out factors that could help make Linux even better.
I mean, just look at the Linux filesystem. Again you have this absurd shortage of characters. Why would anyone abbreviate the word “user[s]” into “usr” ? It make noh sense. Same with “lib”, would it have killed you to call it “libraries”? And so it continues with “dev” – because calling it “devices” would cause the space-time-continuum to break.
Shell shocked
The shell (or command-line under Windows) and it’s commands is really the thing that annoys me the most. There is a fine line between use and abuse, and the level of abbreviation here is beyond whimsical and harmless – and well into the realm of silly and absurd
Who in their right mind would name a command “ps”? What could it possibly mean? The first thing that comes to mind is “print spool”. If you come from any other platform than Linux (and perhaps Unix, I don’t know) you would never imagine that “ps” actually means “list all running processes and their states”.
“ps” lists the running processes and their states
Above: running “ps” from the shell lists the running processes. Would it have killed the coders to just call it, oh perhaps, “listprocesses” or “showrunningprograms”?
The “ps” command is just one in a long, long list of commands that really should be brought into the twenty-first century. The benefits should be obvious. It should not be necessary for a 43-year-old man to blog about this, because it’s been a problem for the better part of three decades.
- Kids and teenagers is the bread and butter for all operating systems. The faster a kid of teenager can do something with a system, the more loyal that individual will be to the platform in the future.
- Linux needs developers and users from other platforms. When someone who has been a successful developer for almost 30 years find a system cryptic and hard to use, how much harder will it be for a non-technical user?
- Standards are important. The location of files, libraries and settings should be uniform. As of writing Linux seem to have 3 different standards (again, I am no expert): systemd, initd and “systemx”. The latter is just a name I made up, because no-one really knows what it’s called. We are now in the realm of PlayStation, ChromeOS, WebOS and systems that build on the Linux – but deviate the moment the drivers have loaded.
Again, I’m not writing this in a negative mindset. I have been using Ubuntu for a while as an alternative to Windows and OS X. But this has been a purely user-centric experience. I have not done any programming except random bits of Freepascal and node.js experiements. I have enjoyed Ubuntu purely as a user. Writing documents, checking email, browsing the web, IRC, reading news groups – ordinary stuff.
So I am very positive to Linux, but I have yet to find “my” flavour of it. A Linux distro I feel at home with and that appeals to my way of working.
Until today that is..
Enter puppy Linux
Puppy is a flavour of Linux that just demolishes some of Linux’s most holiest of concepts. Everyone will tell you never to run as root, always have the root account in peace – and keep it under lock and key just in case someone gets into your second account right?
Well not Puppy. Here you are expected to run as root and you can, if you for some reason must, jump out into a secondary user which is fake. So indeed – puppy Linux is a single user Linux system. It’s the rebel, the scoundrel and rouge of the Linux world – the distro that couldn’t care less what the other guys are doing.
Fancy a spot of coding? GCC is a SFS module away ..
Secondly, and this is very cool, Puppy is highly modular. No I’m not talking about packages, all Linux distros have that in some form or another. No I’m talking about something called SFS files, short for squashed file-system.
To make a long story short, Puppy allows you to mount compressed files as disks and they become a part of the system. It’s a bit like the virtual-drive API on windows (if you have ever coded against that?). You may have noticed in Windows how you can double-click on a .ISO file and suddenly the file is mounted in the file-explorer and stays mounted until you manually dis-mount the damn thing?
Well, SFS is that but also much more. Because when you mount the SFS file whatever applications it contains registers on the start-menu, adds itself to the global path and essentially becomes one with the whole system. This took me a while to wrap my head around this (good features always comes with a price, so i keept waiting for the negative. But there were none!). The people I talked to about this were not coders, so they had some very colorful explanations to how it all worked. But once I realized SFS was just a zip-file (or tarball or whatever) with a fixed structure (including mount script and dis-mount script) I got the picture.
Size and speed matters
Before I started using a PC back in the early 90’s I was a huge Amiga fan. I still am (as you no doubt have noticed). One of the first things I found, or first difference between Amiga computing and PC computing that hit me – was how wasteful PC’s were. I remember I was shocked when I saw how much space and cpu power the average programmer just wasted — because on the Amiga everyone strived to be as resourceful and efficient as possible.
We would spend days optimizing even the smallest parts of our applications just to ensure that it ran at top speed and produced as little bloat as possible. This was just baked into us, it was the way of the force and as common as your grandfather’s work ethics. Quality and achievement went hand in hand.
CodeBlocks is an excellent IDE 🙂
When you fire up Puppy Linux you are instantly reminded that there are people to this day that cares about size and speed. And that maybe, just maybe, consumerism has tricked you into throwing away perfectly usable technology year after year. Machines that actually had more than enough CPU power for the tasks you wanted, but was slowed down by bloated operating-systems, poor programming and lazy code generators.
Puppy Linux is the fastest bloody Linux you will ever run. The only operatingsystem I have tried that runs faster, is Aros compiled for Arm (a distro called Aeros, a reverse engineered edition of Amiga OS). But as far as x86 and the Linux kernel goes — Puppy Linux is the bomb.
I know I’m repeating myself here but: less than 300 megabytes for a fully loaded Linux distro with text processor, browser, devkit, music player, video player and all the “typical” applications you would use for daily tasks? And it truly is the fastest hunk of junk in the galaxy without question.
Amiga coders and the cult of joy
When I started to snoop around the Puppy environment and community, I started to notice a couple of “tell-tell” signs. Tiny, subtle things that only an Amiga coder would pick up on. Enough to give you a hunch, a gut feeling – but not enough to blatantly say it out loud. “Amiga guys did this” i would whisper to myself. And it’s not really such a big surprise to find that coders now in their 40s that used to be Amiga coders.
In 30 years time there will be company owners and CEO’s that grew up with Playstation and have fond memories of that. But they wont recognize each-other by their craftmanship – that is the difference.
The cult of joy lives on, albeit in new forms
The Amiga was special because it was not just a games machine. It was also a complete rewrite of what constituted the power operatingsystem of its time: Unix. In other words they copied the best stuff from Unix (which by the way had the same absurd filesystem as Linux still has) but cleaned it up. First thing to be cleaned was (drumroll) the filesystem. But that’s another story all together.
When I entered the Puppy Linux forum I naturally mentioned that I was a complete total Linux novice, and that my favorite machine before x86 was an Amiga. And what do you think happened? Let’s just say that more than a few greeted me with open arms. These were the Amiga users that went to Linux when Commodore went under all those years ago. And they had been active in shaping Linux ever since (!)
So yeah, had a great time on their forums – and it was like running into your long-lost cousin or something. Like if you havent seen a family member in 30 years and suddenly you meet them face to face.
Tired of 30 gigabyte operatingsystems?
Puppy Linux is not for everyone. It’s the kind of system you either love or hate. I have yet to find someone on a middle-ground regarding puppy. Either you love it, or you hate it. Or if you prefer: either you use it and are thrilled about it, or you never install it.
It has a lot of good things going for it:
- It is built to be one of the smallest, working desktop environment you can get
- It is built according to “the old ways”, where speed, efficiency and size matter
- It runs fine on older hardware (my test machine is an 8 year old laptop) and makes stuff you would otherwise throw away become valuable again.
- It is storage abstracted, meaning you can have all your personal stuff inside a single SFS archive (easier to back up), while the operatingsystem remains on a USB stick.
- You don’t have to permanently install it (again, boot from a USB stick).
- It is single user by default, which is perfect for IOT projects and devices!
- It supports ARM, so you can now enjoy this awesome thing on Raspberry PI 3 !
- Its Linux so it has all the benefits of a rich driver database
- Latest Puppy is binary compatible with Ubuntu (whatever that means)
- There are 3 different desktops for it (to my knowledge), so if you don’t like the default client just install something else
- It is the perfect rescue USB stick. At less than 300 Mb you can fit it on any old USB stick you have around the house. I think the smallest you can buy now is 4 GB
- It has a warm, helpful, friendly and international group of users
Oh and it’s free!
As a final note: I installed Wine, the system that makes it possible to run Windows software on Linux (not an emulator, more of a api-call middle-ware /slash/ dispatcher). I was quite surprised to see it run Smart Mobile Studio on the first try!
So fancy a bit of hacking this weekend? Why not give puppy a go?
Check it out here: http://puppylinux.org/main/Download%20Latest%20Release.htm
Smart Pascal + WebOS = true
If you own a television (and who doesn’t) chances are you own an LG model. The LG brand has been on the market since before recorded history (or so it feels) and have been a major player for decades.
What is little known though, is that LG also owns and finance a unique operating system. This is not uncommon these days, most NAS and cloud vendors have their own system (there are roughly 20 cloud based systems on the market that I know of). The only way to make a Smart TV (sigh) is to add a computer to it. And if you buy a television today chances are it contains a small embedded board running some custom-made operating system designed to do just that.
Every vendor has their own system, and those that don’t usually end up forking Android and adapt that to their needs.
Luna WebOS
LG’s system is called WebOS. This may sound like yet another html eye candy front end, but hear me out because this OS is not what it seems.
Except for some font issues (see disk label) Smart loaded fine under WebOS
Remember Palm OS? If you are between 35 and 45 you should remember that before Apple utterly demolished the mobile-phone market with their iPhone, one of the most popular brands was Palm. Their core product being “Palm Pilot”, a kind of digital filo-fax (personal organizer) and mobile phone rolled into one.
WebOS is based on what used to be called Palm-OS, but it has been completely revamped, given a sexy new user interface (looks a lot like android to be honest!) and brought into the present age. And best of all: its 100% free! It runs on a plethora of systems, from x86 to Raspberry PI to Mips. It is used in televisions, terminals and set-top-boxes around the world – and is quite popular amongst engineers.
Check it out their new portal here; there is also plenty of links to pre-built images if you look around there: https://pivotce.com/
JavaScript application stack
One of the coolest features in my view, is that their applications are primarily made by JavaScript. The OS itself is native of course, but they have discovered that JavaScript and HTML5 is an excellent way to build applications. Applications that is easy to control, sandboxed and safe yet incredibly powerful and capable.
Smart Desktop booting Quake 3 in Luna OS
Well, today I sent them an Email requesting their SDK. I know they use Enyo.js as their primary and suggested framework – but that is no problem for Smart Mobile Studio. A better question is: can Luna handle our codebase?
When I loaded up Quake 3 in pure Asm.JS the TV crashed with a spectacular access violation. So they are probably not used to the level of hardcore coding Smart developers represent. But yeah, Quake III is about as advanced as it gets – and it pushes any browser to the outer limits of what is possible.
Once I get the SDK, docs and a few examples – I will begin adding support for it as quickly as possible. Which means you get a new project type especially for the platform + API units (typically stored under $RTL\Apis folder).
Why is this cool?
Because with support for Luna / WebOS, you as a Delphi or Smart developer can offer your services to companies that use WebOS or Luna (the open source version) in their devices. The list of companies is substantial – and they are well established companies. And as you have no doubt noticed, hardware engineers doesn’t always make the best software engineers. So this opens up plenty of opportunities for a good object pascal / Smart developer.
Luna has an Android like quality over it – except its more smooth to use
Remember – other developers will use vanilla JavaScript. You have the onslaught of the VJL and the might of our libraries at your disposal. You can produce in days what others use weeks on achieving.
These are exciting days! I’ll keep you posted on our progress!
Smart Pascal, the next generation
I want to take the time to talk a bit about the future, because like all production companies we are all working towards lesser and greater goals. If you don’t have a goal then you are in trouble; Thankfully our goals have been very clear from the beginning. Although I must admit that our way there has been.. “colorful” at times.
When we started back in 2010 we didn’t really know what would become of our plans. We only knew that this was important; there was a sense of urgency and “we have to build this” in the air; I think everyone involved felt that this was the case, without any rational explanation as to why. Like all products of passion it can consume you in a way – and you work day and night on turning an idea into something real. From the intangible to the tangible.
It seems like yesterday, but it was 5 years ago!
By the end of 2011 / early 2012, Eric and myself had pretty much proven that this could be done. At the time there were more than enough nay-sayers and I think both of us got flamed quite often for daring to think different. People would scoff at me and say I was insane to even contemplate that object pascal could ever be implemented for something as insignificant and mediocre as JavaScript. This was my first meeting with a sub-culture of the Delphi and C++ community, a constellation I have gone head-to-head with on many occasions. But they have never managed to shake my resolve as much as inch.
When we released version 1.0 in 2012 some ideas about what could be possible started to form. Jørn defined plans for a system we later dubbed “Smart net”. In essence it would be something you logged onto from the IDE – allowing you to store your projects in the cloud, compile in the cloud (connected with Adobe build services) and essentially move parts of your eco-system to the cloud. Keep in mind this was when people still associated cloud with “storage”; they had not yet seen things like Uber or Netflix or played Quake 3 at 160 frames per second, courtesy of asm.js in their browser.
The second part would be a website where you could do the same, including a live editor, access to the compiler and also the ability to buy and sell components, solutions and products. But for that we needed a desktop environment (which is where the Quartex Media Desktop came in later).
The first version of the Media Desktop, small but powerful. Here running in touch-screen mode with classical mobile device layout (full screen forms).
Well, we have hit many bumps along the road since then. But I must be honest and say, some of our detours have also been the most valuable. Had it not been for the often absurd (to the person looking in) research and demo escapades I did, the RTL wouldn’t be half as powerful as it is today. It would deliver the basics, perhaps piggyback on Ext.js or some lame, run of the mill framework – and that would be that. Boring, flat and limited.
What we really wanted to deliver was a platform. Not just a website, but a rich environment for creating, delivering and enjoying web and cloud based applications. And without much fanfare – that is ultimately what the Smart Desktop and it’s sexy node.js back-end is all about is all about.
We have many project types in the pipeline, but the Smart Desktop type is by far the most interesting and powerful. And its 100% under your control. You can create both the desktop itself as a project – and also applications that should run on that desktop as separate projects.
This is perfectly suited for NAS design (network active storage devices can usually be accessed through a web portal on the device), embedded boards, intranets and even intranets for that matter.
You get to enjoy all the perks of a multi-user desktop, one capable of both remote desktop access, telnet access, sharing files and media, playing music and video (we even compiled the mp4 codec from C to JavaScript so you can play mp4 movies without the need for a server backend).
The Smart Desktop
The Smart Desktop project is not just for fun and games. We have big plans for it. And once its solid and complete (we are closing in on 46% done), my next side project will not be more emulators or demos – it will be to move our compiler(s) to Amazon, and write the IDE itself from scratch in Smart Pascal.
The Smart Desktop – A full desktop in the true sense of the word
And yeah, we have plans for EmScripten as well – which takes C/C++ and compiles it into asm.js. It will take a herculean effort to merge our RTL with their sandboxed infrastructure – but the benefits are too great to ignore.
As a bonus you get to run native 68k applications (read: Amiga applications) via emulation. While I realize this will be mostly interesting for people that grew up with that machine – it is still a testament to the power of Smart and how much you can do if you really put your mind to it.
Naturally, the native IDE wont vanish. We have a few new directions we are investigating here – but native will absolutely not go anywhere. But cloud, the desktop system we are creating, is starting to become what we set out to make five years ago (has it been half a decade already? Tempus fugit!). As you all know it was initially designed as an example of how you could write full-screen applications for Raspberry PI and similar embedded devices. But now its a full platform in its own right – with a Linux core and node.js heart, there really is very little you cannot do here.
The Smart Pascal compiler is one of our tools that is ready for cloud-i-fication
Being able to login to the Smart company servers, fire up the IDE and just code – no matter if you are: be it Spain, Italy, Egypt, China or good old USA — is a pretty awesome thing!
Clicking compile and the server does the grunt work and you can test your apps live in a virtual window; switch between device layouts and targets — then hit “publish” and it goes to Cordova (or Delphi) and voila – you get a message back when binaries for 9 mobile devices is ready for deployment. One click to publish your applications on Appstore, Google play and Microsoft marketplace.
Object pascal works
People may have brushed off object pascal (and from experience those people have a very narrow view of what object pascal is all about), but when they see what Smart delivers, which in itself is written in Delphi, powered by Delphi and should be in every Delphi developer’s toolbox — i think it should draw attention to both Delphi as a product, object pascal as a language – and smart as a solution.
With Smart it doesn’t matter what computer you use. You can sit at home with the new A1222 PPC Amiga, or a kick-ass Intel i7 beast that chew virtual machines for breakfast. If your computer can handle a modern website, then you can learn object pascal and work directly in the cloud.
The Smart Desktop running on cheap embedded hardware. The results are fantastic and the financial savings of using Smart Pascal on the kiosk client is $400 per unit in this case
Heck you can work off a $60 ODroid XU4, it has more than enough horsepower to drive the latest chrome or Firefox engines. All the compilation takes place on the server anyways. And if you want a Delphi vessel rather than phonegap (so that it’s a Delphi application that opens up a web-view in full-screen and expose features to your smart code) then you will be happy to know that this is being investigated.
More targets
There are a lot of systems out there in the world, some of which did not exist just a couple of years ago. FriendOS is a cloud based operating system we really want to support, so we are eager to get cracking on their SDK when that comes out. Being able to target FriendOS from Smart is valuable, because some of the stuff you can do in SMS with just a bit of code – would take weeks to hand write in JavaScript. So you get a productive edge unlike anything else – which is good to have when a new market opens.
As far as Delphi is concerned there are smaller systems that Embarcadero may not be interested in, for example the many embedded systems that have come out lately. If Embarcadero tried to target them all – it would be a never-ending cat and mouse game. It seems like almost every month there is a new board on the market. So I fully understand why Embarcadero sticks to the most established vendors.
Smart technology allows you to cover all your bases regardless of device
But for you, the programmer, these smaller boards can repsent thousands of dollars worth of saving. Perhaps you are building a kiosk system and need to have a good-looking user interface that is not carved in stone, touch capabilities, low-latency full-duplex communication with a server; not much you can do about that if Delphi doesnt target it. And Delphi is a work horse so it demands a lot more cpu than a low-budget ARM SoC can deliver. But web-tech can thrive in these low-end environments. So again we see that Smart can compliment and be a valuable addition to Delphi. It helps you as a Delphi developer to act on opportunities that would otherwise pass you by.
So in the above scenario you can double down. You can use Smart for the user-interface on a low power, low-cost SoC (system on a chip) kiosk — and Delphi on the server.
It all depends on what you are interfacing with. If you have a full Delphi backend (which I presume you have) then writing the interface server in Delphi obviously makes more sense.
If you don’t have any back-end then, depending on your needs or future plans, it could be wise to investigate if node.js is right for you. If it’s not – go with what you know. You can make use of Smart’s capabilities either way to deliver cost-effective, good-looking device front-ends of mobile apps. Its valuable tool in your Delphi toolbox.
Better infrastructure and rooting
So far our support for various systems has been in the form of APIs or “wrapper units”. This is good if you are a low-level coder like myself, but if you are coming directly from Delphi without any background in web technology – you wouldn’t even know where to start.
So starting with the next IDE update each platform we support will not just have low-level wrapper units, but project types and units written and adapted by human beings. This means extra work for us – but that is the way it has to be.
As of writing the following projects can be created:
- HTML5 mobile applications
- HTML5 mobile console applications
- Node.js console applications
- node.js server applications
- node.js service applications (requires PM2)
- Web worker project (deprecated, web-workers can now be created anywhere)
We also have support for the following operating systems:
- Chrome OS
- Mozilla OS
- Samsung Tizen OS
The following API’s have shipped with Smart since version 1.2:
- Khronos browser extensions
- Firefox spesific API
- NodeWebkit
- Phonegap
- Phonegap provides native access to roughly 9 operating systems. It is however cumbersome to work with and beta-test if you are unfamiliar with the “tools of the trade” in the JavaScript world.
- Whatwg
- WAC Apis
Future goals
The first thing we need to do is to update and re-generate ALL header files (or pascal units that interface with the JavaScript libraries) and make what we already have polished, available, documented and ready for enterprise level use.
Why pay $400 to power your kiosk when $99 and Smart can do a better job?
Secondly, project types must be established where they make sense. Not all frameworks are suitable for full project isolation, but act more like utility libraries (like jQuery or similar training-wheels). And as much as possible of the RTL made platform independent and organized following our namespace scheme.
But there are also other operating systems we want to support:
- Norwegian made Friend OS, which is a business oriented cloud desktop
- Node.js OS is very exciting
- LG WebOS, and their Enyo application framework
- Asustor DLM web operating system is also a highly attractive system to support
- OpenNAS has a very powerful JavaScript application framework
- Segate Nas OS 4 likewise use JavaScript for visual, universal applications
- Microsoft Universal Platform allows you to create truly portable, native speed JavaScript applications
- QNap QTS web operating system [now at version 4.2]
All of these are separate from our own NAS and embedded device system: Smart Desktop, which uses node.js as a backend and will run on anything as long as node and a modern browser is present.
Final words
I hope you guys have enjoyed my little trip down memory lane, and also the plans we have for the future. Personally I am super excited about moving the IDE to the cloud and making Smart available 24/7 globally – so that everyone can use it to design, implement and build software for the future right now.
Smart Pascal Builder (or whatever nickname we give it) is probably the first of its kind in the world. There are a ton of “write code on the web” pages out there, but so far there is not a single hard-core development studio like I have in mind here.
So hold on, because the future is just around the corner 😉
Delphi developer on its own server
While the Facebook group will naturally continue exactly like it has these past years, we have set up a server active Delphi developers on my Quartex server.
This has a huge benefit: first of all those that want to test the Smart Desktop can do so from the same domain – and people who want to test Smart Mobile Studio can do so with myself just a PM away. Error reports etc. will still need to be sent to the standard e-mail, but now I can take a more active role in supervising the process and help clear up whatever missunderstanding could occur.
Always good with a hardcore Smart, Laz, amibian.js forum!
Besides that we are building a lively community of Delphi, Lazarus, Smart and Oxygene/Remobjects developers! Need a job? Have work you need done? Post an add — wont cost you a penny.
So why not sign up? Its free, it wont bite you and we can continue regardless of Facebook’s up-time this year..
You enter here and just fill out user/pass and that’s it: http://quartexhq.myasustor.com/sharetronix/
Smart Pascal: Busting browser storage limits
Sessionstorage is the name for a browser’s in-memory only storage. Meaning that it’s essentially a ram-disk that is just deleted when you navigate away from the website or close the browser.
Sessionstorage has also been deprecated, so you should avoid using it and go for Localstorage, or just use a raw, untyped uint8 array instead.
Or should you?
Ensuring 64 megabytes minimum
Browsers do not behave identically across devices. Try to get a concurrent reading of something as simple as drawing sprites, and you will quickly notice that even the same device families (Android, iOS and Microsoft) can behave differently between versions – and even builds (revisions).
On embedded systems or thin clients with very little memory, allocating large chunks ot uint8 arrays is not going to work. One of my test thin-client machines has only 512 megabyte ram – and it would throw an exception if I tried to allocate more than 20 megabyte of continuous memory (again, as an array of uint8 bytes).
Using the dark side of the force
Offline means the system boots from a local cache disk
While testing Smart code on this little device, I noticed that quite large images loaded just fine. So where I was not allowed to allocate more than 20 megabytes, the browser would happily load in pictures taking up over 50 megabyte of pixel data?
It then struck me that the maximum limit of a picture, which is enforced by the DIB Api (at least on Windows desktop and embedded), is 4000 x 4000 pixels. Since each pixel is 32 bits (4 bytes, RGBA) that my friend is 64 megabytes right there!
I created a new class that inherits from the virtual-filesystem that Smart Pascal uses, created an off-screen image object in the constructor – and then made a simple but effective “bytes to scan line” calculation routine. So whenever the need for more data grew, it would first grow the picture so it could hold the data (and shrink it again) on demand.
Humble but meaningful
Now 64 megabytes might not seem like much in our day and age, but if you are on holiday and want to connect to your home NAS – 64 megabytes of available ram makes a huge difference. Remember that localstorage only allows between 5 and 10 megabytes.
I should mention that using an image as a buffer makes little sense on a full Windows PC, a Mac or a Linux box. These system will page memory to disk and you will most likely never encounter the 20 megabyte barrier I experienced on this low-end Dell thin client device. But considering that hotels, motels and b&b often have thin clients setup for their customers (read: you) – The Smart desktop has to take height for it.
Smart desktop: Amibian.js past, future and present
Had someone told me 20 years ago that I would enter my 40’s enjoying JavaScript, my younger self would probably have beaten that someone over the head with a book on hardcore demo coding or something. So yeah, things have changed so much and we are right now in the middle of a paradigm shift that is taking us all to the next level – regardless if we agree or not.
Ask a person what he thinks about “cloud” and you rarely get an answer that resembles what cloud really is. Most will say “its a fancy way of dealing with storage”. Others will say its all about web-services – and others might say it’s about JavaScript.
Old coders never die, we just get better
They are all right and wrong at the same time. Cloud is first of all the total abstraction of all parts that makes up a networked computer system. Storage, processing capacity, memory, operating system, services, programming language and even instruction set.
Where a programmer today works with libraries and classes to create programs that run on a desktop — dragging visual controls like edit-boxes and buttons into place using a form or window designer; a cloud developer builds whole infrastructures. He drags and drops whole servers into place, connects external and internal services.
Storage? Ok I need Dropbox, amazon, Google drive, Microsoft one disk, local disk – and he just drags that onto a module. Done. All of these services now have a common API that allows them to talk with each other. They become like dll files or classes, all built using the same mold – but with wildly different internals. It doesn’t matter as long as they deliver the functionality according to standard.
Processing power? Setup an Azure or Amazon account and if you got the cash, you can compute enough to pre-cacalculate the human brain if you like. It has all been turned into services — that you can link together like lego pieces.
Forget everything you think you know about web; that is but the visual rendering engine over the proverbial death-star of technology hidden beneath. People have only seen the tip of the ice berg.
Operating systems have been reduced to a preference. There is no longer any reason to pick Windows over Linux on the server. Microsoft knew years ago that this day would come. Back in the late 90s I remember reading an interview with Steve Balmer doing one of his black-ops meetings with Norwegian tech holders in Oslo; and he outlined software as a service when people were on 14.4 modems. He also mentioned that “we need a language that is universal” to make this a reality. You can guess why .net was stolen from Borland, not to mention their failed hostile takover of Java (or J#) which Anders Hejlsberg was hired to spear-head.
Amibian.js
Amibian.js is my, Gunnar and Thomas‘s effort to ensure that the Amiga is made portable and can be enjoyed in this new paradigm. It is not made to compete with anyone (as was suggested earlier), but rather to make sure Amiga gets some life into her again – and that people of this generation and the kids growing up now can get to enjoy the same exciting environment that we had.
From Scandinavia with love
The world is going JavaScript. Hardware now speaks JavaScript (!), your TV now speaks JavaScript – heck your digital watch probably runs JavaScript. And just to add insult to injury – asm.js now compiles JS code side-by-side with C/C++ in terms of speed. I think the browser has seen more man years of development time than any other piece of software out there – with the exception of GCC / Gnu Linux perhaps.
Amibian is also an example of a what you can do with Smart Pascal, which is a programming environment that compiles object pascal to JavaScript. One we (The Smart Company AS) made especially for this new paradigm. I knew this was coming years ago – and have been waiting for it. But that’s another story all together.
Future
Well, naturally the desktop system is written from scratch so it needs to be completed. We are at roughly 40% right now. But there is also work to be done on UAE.js (a mild fork of sae, scriptable Amiga emulator) in terms of speed and IO. We want the emulated Amiga side to interact with the modern web desktop – to be able to load and save files to whatever backend you are using.
For those about to rock; We salute you!
Well, it’s not that easy. UAE is like an organism, and introducing new organs into an existing creature is not easily done. UAE.js (or SAE) has omitted a huge chunk of the original code – which also includes the modified boot-code that adds support for external or “virtual” UAE drives (thanks to Frode Solheim of Fs-UAE for explaining the details of the parts here).
But, there are hacker ways. The dark side is a pathway to many abilities, some deemed unnatural. So if all else fails, i will kidnap the hardfile API and delegate the IO signals to the virtual filesystem on the server — in short, UAE.JS will think it’s booting from a hardfile in memory – when in reality it will get its data from node.js.
There are some challenges here. UAE (the original) is not async but ordinary, linear C code. JavaScript is async and may not return the data on exit of the method. So i suspect I will have to cache quite a lot. Perhaps as much as 1 megabyte backwards and forwards from the file-position. But getting data in there we will (and out), come hell or high water.
We can also drop a lot of sub code, like parts of the gayle interface. I found out this is the chip that deals with the IDE interface — so it has to be there, but it can also host memory expansions – but who the hell cares in 2017 in JavaScript about that. More than enough fun via standard chip/fast/rtg memory – so the odd bits can be removed.
So we got our work cut out for us. But hey.. there can only be one .. QUARTEX! And we bring you fire.
Ok. Lets do this!
Jon L. Aasenden 
You must be logged in to post a comment.