RISC OS

Error message

  • Warning: date_timezone_set() expects parameter 1 to be DateTime, boolean given in format_date() (line 2062 of /home/scslive/public_html/includes/common.inc).
  • Warning: date_format() expects parameter 1 to be DateTimeInterface, boolean given in format_date() (line 2072 of /home/scslive/public_html/includes/common.inc).

RISC OS source code to be relicensed under the Apache open source license

The Iconbar - Mon, 10/22/2018 - 20:40
Hot on the heals of the reveal that RISC OS Developments had acquired Castle Technology and with it the rights to RISC OS 5, more news on the future of RISC OS has emerged this week: RISC OS Developments are working with RISC OS Open to relicense RISC OS under the Apache 2.0 License, a popular and fairly permissive open-source license.

Although some the OS's components were already available under permissive open-source licenses such as the BSD and CDDL licenses, ever since RISC OS Open's inception the primary license has been the Castle License, which came in commercial and non-commercial flavours, neither of which satisfied all of the requirements that the OSI deem necessary in order for the code released under that license to be considered "true" open source. So although the "shared source" Castle License was better than nothing and certainly played a big part in RISC OS's survival post-Iyonix, many people have also felt that it's been holding the platform back. ROOL and ROD hope that by relicensing the OS under this new license, developer and user interest in the OS will increase, and the OS will be kept free to grow and evolve into the next decade and beyond.

More information about what this means for RISC OS and what ROD's and ROOL's plans for the future of RISC OS are will be released at the London Show this weekend.

No comments in forum

Categories: RISC OS

More Acorn Magazine nostalgia

The Iconbar - Sat, 10/13/2018 - 11:20
In a previous article, we covered some of the online resources for reading online some of the magazine from past years.

Now you can also enjoy the whole of The Frobnicate collection online. There has also been some lively discussion on the magazines online in the ROOL forums.

There is also some good content (especially technical articles) from ">Acorn User.

And if you want something right to to date, we should see new editions from Archive and Drag'n'Drop around the London show.

No comments in forum

Categories: RISC OS

RISC OS London Show 2018

The Iconbar - Fri, 10/05/2018 - 08:00
This year's London Show is due to take place on Saturday the 27th of October, at the usual location of the St. Giles Hotel in Feltham. The show runs from 11 AM to 5 PM, with tickets being £5 at the door (and under-16's free). Exhibitors this year are set to include:If that's not enough, there's also likely to be a full set of theatre presentations, from presenters including CJE, R-Comp, RISC OS Developments, and RISC OS Open.

Be sure to visit the show's website for up-to-the-minute news in the run-up to the show.

No comments in forum

Categories: RISC OS

September News round-up

The Iconbar - Fri, 09/28/2018 - 06:57
Some things we noticed this month. What did you see?

Orpheus Internet hits crowdfunding target.

Elesar offering a free 128GB SSD drive promotion with a new Titanium bought before 8th October.

Some packaging confessions and advice on running RISCOS OS directly on Linux The RISC OS Blog.

A video of ARM's 1992 presentation to Apple about the ARM610 - YouTube / Centre for Computing History

Reminder there is a show next month....

No comments in forum

Categories: RISC OS

DDE tools updated to DDE28c

The Iconbar - Fri, 09/21/2018 - 06:00
Over the summer, ROOL quietly slipped out another update to their DDE toolset. We saw an update in April and the July release of DDEc is another incremental release.

There are some changes to !C++ and !CC applications and existing users can update just by copying the existing files onto the existing release. New copies on the ROOL store are using the latest release.

While there is no real features, it is really important to see such a critical tool being maintained and updated.

ROOL also mention in their release email the bounty to add ARMv7 inline assembler to the C Compiler. If you are interested in contributing to this bounty, details are here.

No comments in forum

Categories: RISC OS

PackMan in practice

The Iconbar - Fri, 09/14/2018 - 08:00
For this first article looking at how to create PackMan/RiscPkg packages, I've decided to use my SunEd program as a guinea pig. Being a simple C application with no dependencies on other packages, it'll be one of the most straightforward things on my site to get working, and one of the easiest for other people to understand.

Read on to discover how to turn simple apps like SunEd into RiscPkg packages, and more importantly, how to automate the process.

Building your first package, the PackIt way

The RiscPkg policy manual is a rather dry document, so the easiest way of getting your first package built is to use the PackIt tool created by Alan Buckley. After loading PackIt, you can simply drag an application to its iconbar icon and up will pop a window to allow you to enter all the extra details that RiscPkg needs to know.

PackIt's package creation wizard

Once everything is filled in correctly, opening the menu and selecting the "Save" option should allow you to save out the resulting package zip file.

PackIt's output

... except that the current version of PackIt seems to save it out with the wrong filetype. No problem, just manually set the type to 'zip' or 'ddc' and things look a lot better:

The actual package content

Pretty simple, isn't it? The !SunEd app has been placed inside an Apps.File directory (mirroring the default install location for the application on the user's hard disc), while the information that was entered into PackIt's wizard has been saved to the RiscPkg.Control and RiscPkg.Copyright files.

The Control and Copyright files

Control is a simple text file containing the package metadata (the structure of which is the subject of much of the RiscPkg policy document), while Copyright is a verbatim copy of the copyright message you entered into PackIt's window.

PackIt's Copyright tab

Now that you have a package built, you can easily test it out by dragging it to PackMan's iconbar icon. PackMan will then go through the usual installation procedure, just as if it was a package you'd selected to install from the Internet.

Loading the package in PackMan

Automating package building

Filling in PackIt's wizard once the first time you create a package for an app is all well and good, but what about when you want to release an update for the package? Entering the information all over again is going to waste your time and introduce the risk of making mistakes.

Most C/C++ developers are already familiar with using makefiles to build their programs. With a bit of effort, it's possible to create makefiles which can also automate creation of the corresponding RiscPkg package.Before

After a brief bit of preparation, the 2003-vintage SunEd sources were tidied up and a simple makefile was written, allowing the application binary to be easily rebuilt on command.

The original SunEd source tree

CFLAGS = -Wall -mpoke-function-name -O2 -mlibscl -mthrowback -static

CC = gcc -c $(CFLAGS) -MMD
LINK = gcc $(CFLAGS)

SRCS =
suned
limp

OBJS = $(addsuffix .o, $(SRCS))

# Output file
!SunEd/!RunImage: $(OBJS)
$(LINK) -o $@ $^ -mlibscl

# Object files
%.o: %.c
$(CC) -MF d/$(basename $@) -o $@ $<

# Dependencies
-include d/*The original SunEd makefile

As a brief overview:

  • c and h contain the source code as you would expect
  • d and o are used for intermediate files: autogenerate dependencies and object files
  • !SunEd is the full app, ready for distribution, and the makefile is only used to rebuild the !RunImage
And after

Rather than bore you with all the intermediate versions, I figured it was best to just jump straight to the final version of the makefile and the adjusted source structure.

The new SunEd source tree

CFLAGS = -Wall -mpoke-function-name -O2 -mlibscl -mthrowback -static

CC = gcc -c $(CFLAGS) -MMD
LINK = gcc $(CFLAGS)

CP = copy
CPOPT = A~CF~NQR~S~T~V

SRCS =
suned
limp

APP = Apps/File/!SunEd

ROAPP = $(subst /,.,$(APP))
OBJS = $(addprefix build/,$(addsuffix .o, $(SRCS)))

# Output file
build/!RunImage: $(OBJS)
$(LINK) -o $@ $^ -mlibscl

# Object files
build/%.o: src/%.c build/dirs
$(CC) -MF build/d/$(subst /,.,$(basename $@)) -o $@ $<

# Pattern rule for injecting version numbers into files
build/%.sed: src/template/% src/Version build/dirs
sed -f src/Version $< > $@

# Explicit dependency needed for generated file build/VersionNum.sed
build/suned.o: build/VersionNum.sed

# Standard clean rule
clean:
remove binary/zip
remove source/zip
x wipe build ~CFR~V

# Binary RiscPkg archive
binary.zip: build/pkg-dir
remove binary/zip
dir build.pkg
zip -rqI9 ^.^.binary/zip *
dir ^.^

# Source zip archive
source.zip: build/src-mani makefile COPYING
remove source/zip
zip -rqI9 source/zip src makefile COPYING

all: binary.zip source.zip

build/dirs:
cdir build
cdir build.o
cdir build.d
create build.dirs

# Double-colon rules execute in the order they're listed. So placing this rule
# here makes sure that the 'build' folder exists prior to the rule below being
# executed.
build/pkg-mani:: build/dirs

# Double-colon rules with no pre-requisites always execute. This allows us to
# make sure that build/pkg-mani is always up-to-date
build/pkg-mani::
src/manigen src.pkg build.pkg-mani

# Same system as build/pkg-mani
build/src-mani:: build/dirs
build/src-mani::
src/manigen src build.src-mani

# Create the package dir ready for zipping
build/pkg-dir: build/pkg-mani build/!RunImage build/Control.sed build/!Help.sed COPYING
# Copy over the static files
x wipe build.pkg ~CFR~V
$(CP) src.pkg build.pkg $(CPOPT)
# Populate the RiscPkg folder
cdir build.pkg.RiscPkg
$(CP) build.Control/sed build.pkg.RiscPkg.Control $(CPOPT)
$(CP) COPYING build.pkg.RiscPkg.Copyright $(CPOPT)
# Populate the app folder
$(CP) build.!Help/sed build.pkg.$(ROAPP).!Help $(CPOPT)
$(CP) build.!RunImage build.pkg.$(ROAPP).!RunImage $(CPOPT)
# Create the dummy file we use to mark the rule as completed
create build.pkg-dir

# Dependencies
-include build/d/*The new SunEd makefile

As you can see, there have been a fair number of changes. Not all of them are strictly necessary for automating package creation (after all, a package is little more than a zip file), but this structure has resulted in a setup that helps to minimise the amount of work I'll need to do when preparing new releases. The setup should also be easily transferrable to the other software I'll be wanting to package.What it does

  • The clean rule reduces things to the state you see above
  • The source.zip rule builds a source archive, containing exactly what you see above
  • The binary.zip rule builds the RiscPkg archive, performing the following operations to get there:
    • A copy of the src.pkg folder is made, in order to provides the initial content of the package zip - essentially, the static files which aren't modified/generated by the build.
    • As you'd expect, the !RunImage file gets built and inserted into the app. But that's not all!
    • The src.Version file is actually a sed script containing the package version number and date:

      s/__UPSTREAM_VERSION__/2.33/g
      s/__PACKAGE_VERSION__/1/g
      s/__RISCOSDATE__/28-Aug-18/gThe src.Version file

      This sed script is applied to src.template.!Help to generate the help file that's included in the package, src.template.Control to generate the RiscPkg.Control file, and src.template.VersionNum. By driving all the version number / date references off of this one file, there won't be any embarrassing situations where a built program will display one version number in one location but another version number in another location.

    • src.template.VersionNum is a C header file, which is used to inject the app version and date into !RunImage.
    • The COPYING file in the root used as the RiscPkg.Copyright file in the package.
  • All the intermediate files will be stored in a build folder, which helps keen the clean and source.zip rules simple.
  • Full dependency tracking is used for both the source.zip and binary.zip targets - adding, removing, or changing any of the files in src.pkg (or anywhere else, for source.zip) will correctly result in the resulting target being rebuilt. This is achieved without introducing any situations where the targets are redundantly built - so a build system which tries to build tens or hundreds of packages won't be slowed down.
manigen

There are also a few extra files. The src.notes folder is a collection of notes from my reverse-engineering of the SunBurst save game format, which I've decided to include in the source archive just in case someone finds it useful. But that's not really relevant to this article.

manigen, on the other hand, is relevant. It's a fairly short and straightforward BASIC program, but it plugs a very large hole in make's capabilities: Make can only detect when files change, not directories. If you have a directory, and you want a rule to be executed whenever the contents of that directory changes, you're out of luck. For small projects like SunEd this isn't so bad, but for bigger projects it can be annoying, especially when all you really want to do with the files is archive them in a zip file.

Thus, manigen ("manifest generator") was born. All it does is recursively enumerate the contents of a directory, writing the filenames and metadata (length, load/exec addr, attributes) of all files to a single text file. However, it also compares the new output against the old output, only writing to the file if a change has been detected.

out%=0
ON ERROR PROCerror

REM Parse command line args
SYS "OS_GetEnv" TO args$
REM First 3 options will (hopefully) be 'BASIC --quit ""'
opt$ = FNgetopt : opt$ = FNgetopt : opt$=FNgetopt
REM Now the actual args
dir$ = FNgetopt
out$ = FNgetopt

DIM result% 1024

out%=OPENUP(out$)
IF out%=0 THEN out%=OPENOUT(out$)
mod%=FALSE

PROCprocess(dir$)
IF EOF#out%=FALSE THEN mod%=TRUE
IF mod% THEN EXT#out%=PTR#out%
CLOSE#out%
REM Oddity: Truncating a file doesn't modify timestamp
IF mod% THEN SYS "OS_File",9,out$
END

DEF PROCprocess(dir$)
LOCAL item%
item%=0
WHILE item%<>-1
SYS "OS_GBPB",10,dir$,result%,1,item%,1024,0 TO ,,,read%,item%
IF read%>0 THEN
n%=20
name$=dir$+"."
WHILE result%?n%<>0
name$=name$+CHR$(result%?n%)
n%+=1
ENDWHILE
PROCwrite(name$+" "+STR$~(result%!0)+" "+STR$~(result%!4)+" "+STR$~(result%!8)+" "+STR$~(result%!12))
IF result%!16=2 THEN PROCprocess(name$)
ENDIF
ENDWHILE
ENDPROC

DEF FNgetopt
LOCAL opt$
opt$=""
WHILE ASC(args$)>32
opt$ = opt$+LEFT$(args$,1)
args$ = MID$(args$,2)
ENDWHILE
WHILE ASC(args$)=32
args$ = MID$(args$,2)
ENDWHILE
=opt$

DEF PROCerror
PRINT REPORT$;" at ";ERL
IF out%<>0 THEN CLOSE#out%
END

DEF PROCwrite(a$)
LOCAL b$,off%
IF EOF#out% THEN mod%=TRUE
IF mod%=FALSE THEN
off%=PTR#out%
b$=GET$#out%
IF a$<>b$ THEN mod%=TRUE : PTR#out%=off%
ENDIF
IF mod% THEN BPUT#out%,a$
ENDPROCmanigen

On Unix-like OS's this is the kind of thing you could knock together quite easily using standard commands like find, ls, and diff. But the built-in *Commands on RISC OS aren't really up to that level of complexity (or at least not without the result looking like a jumbled mess), so it's a lot more sensible to go with a short BASIC program instead.

The usage of manigen in the makefile is described in more detail below.Makefile magic

Looking at each section of the makefile in detail:Pattern rules

# Object files
build/%.o: src/%.c build/dirs
$(CC) -MF build/d/$(subst /,.,$(basename $@)) -o $@ $<

The pattern rule used for invoking the C compiler has changed. Output files are placed in the build directory, and input files come from the src directory. The substitution rule is used to remove the directory separators from the filename that's used for the dependency files, so that they'll all be placed directly in build.d. If they were allowed to be placed in subdirectories of build.d, we'd have to create those subdirectories manually, which would be a hassle.

# Pattern rule for injecting version numbers into files
build/%.sed: src/template/% src/Version build/dirs
sed -f src/Version $< > $@

Another pattern rule is used to automate injection of the package version number and date into files: Any file X placed in src.template can have its processed version available as build.X/sed (or build/X.sed as a Unix path). The sed extension is just a convenient way of making sure the rule acts on the right files.build/dirs

Both of the above rules are also configured to depend on the build/dirs rule - which is used to make sure the build directory (and critical subdirectories) exist prior to any attempt to place files in there:

build/dirs:
cdir build
cdir build.o
cdir build.d
create build.dirs

The file build.dirs is just a dummy file which is used to mark that the rule has been executed.Explicit dependencies

# Explicit dependency needed for generated file build/VersionNum.sed
build/suned.o: build/VersionNum.sed

Although most C dependencies are handled automatically via the -MF compiler flag (and the -include makefile directive), some extra help is needed for build.VersionNum/sed because the file won't exist the first time the compiler tries to access it. By adding it as an explicit dependency, we can make sure it gets generated in time (although it does require some discipline on our part to make sure we keep track of which files reference build.VersionNum/sed)Double-colon rules

# Double-colon rules execute in the order they're listed. So placing this rule
# here makes sure that the 'build' folder exists prior to the rule below being
# executed.
build/pkg-mani:: build/dirs

# Double-colon rules with no pre-requisites always execute. This allows us to
# make sure that build/pkg-mani is always up-to-date
build/pkg-mani::
src/manigen src.pkg build.pkg-mani

Double-colon rules. The manigen program solves the problem of telling make when the contents of a directory have changed, but it leaves us with another problem: We need to make sure manigen is invoked whenever the folder we're monitoring appears in a build rule. The solution for this is double-colon rules, because they have two three very useful properties, which are exploited above:

  1. A double-colon rule with no pre-requisites will always execute (whenever it appears in the dependency chain for the current build target(s)). This is the key property which allows us to make sure that manigen is able to do its job.
  2. You can define multiple double-colon rules for the same target.
  3. Double-colon rules are executed in the order they're listed in the makefile. So by having a rule which depends on build/dirs, followed by the rule that depends on nothing, we can make sure that the build/dirs rule is allowed to create the build folder prior to manigen in the second rule writing its manifest into it.
Of course, we could have just used one build/pkg-mani rule which manually creates the build folder every time it's executed. But the two-rule version is less hacky, and that's kind of the point of this exercise.Creating the package directory

This is a fairly lengthy rule which does a few different things, but they're all pretty simple.

# Create the package dir ready for zipping
build/pkg-dir: build/pkg-mani build/!RunImage build/Control.sed build/!Help.sed COPYING
# Copy over the static files
x wipe build.pkg ~CFR~V
$(CP) src.pkg build.pkg $(CPOPT)
# Populate the RiscPkg folder
cdir build.pkg.RiscPkg
$(CP) build.Control/sed build.pkg.RiscPkg.Control $(CPOPT)
$(CP) COPYING build.pkg.RiscPkg.Copyright $(CPOPT)
# Populate the app folder
$(CP) build.!Help/sed build.pkg.$(ROAPP).!Help $(CPOPT)
$(CP) build.!RunImage build.pkg.$(ROAPP).!RunImage $(CPOPT)
# Create the dummy file we use to mark the rule as completed
create build.pkg-dir

Since there are many situations in which the copy command will not copy, I've wrapped up the right options to use in a variable. Care is taken to specify all the options, even those which are set to the right value by default, just in case the makefile is being used on a system which has things configured in an odd manner.

CP = copy
CPOPT = A~CF~NQR~S~T~V

In this case some of the options are redundant, since this rule completely wipes the destination directory before copying over the new files. But for bigger projects it might make sense to build the directory in a piecemeal fashion, where the extra options are needed.

Once the directory is built, the binary.zip rule can produce the resulting zip file:

# Binary RiscPkg archive
binary.zip: build/pkg-dir
remove binary/zip
dir build.pkg
zip -rqI9 ^.^.binary/zip *
dir ^.^

Note that in this case I could have merged the binary.zip and build/pkg-dir rules together, since build/pkg-dir is only used once. And arguably they should be merged together, just in case I decide to test the app by running the version that's in the build.pkg folder, but it then writes out a log file or something that then accidentally gets included in the zip when I invoke the binary.zip rule later on.

But, on the other hand, keeping the two rules separate means that it's easy to add a special test rule that copes the contents of build.pkg somewhere else for safe testing of the app. And as mentioned above, for big apps/packages it may also make sense to break down build/pkg-dir into several rules, since wiping the entire directory each time may be a bit inefficient.In closing

With a setup like the above, it's easy to automate building of packages for applications. Next time, I'll be looking at how to automate publishing of packages - generating package index files, generating the pointer file required for having your packages included in ROOL's index, and techniques for actually uploading the necessary files to your website.

No comments in forum

Categories: RISC OS

Orpheus hits crowdfunding target

The Iconbar - Tue, 09/11/2018 - 16:26
In July, Orpheus announced their plan to crowdfund their new project.

With their usual modesty, they quietly recently updated their website to say the Company had raised the target figure and work has begun. Excellent news for RISC OS market and for their customers.....

On a personal note, my 6 year old router had issues over the weekend. Richard Brown from Orpheus was on the phone sorting it out at 9am on Saturday morning and helping me to sort out a replacement router asap.....

Orpheus Internet website

No comments in forum

Categories: RISC OS

RISC OS interview with Jerverm Vermeulen

The Iconbar - Fri, 09/07/2018 - 05:53
This time, it is our pleasure to interview Jerverm Vermeulen, who has just released a RISC OS remake of the old BBC Micro game Dickie Brickie, which is now free on !Store.

Would you like to introduce yourself?
My name is Jeroen Vermeulen and I’m from The Netherlands. Recently I’ve remade the BBC Micro game Dickie Brickie for RISC OS which is available from the PlingStore.

How long have you been using RISC OS?
I’ve used RISC OS way back in the past and only quite recently came back to it. My experience with RISC OS started when I bought a Acorn A3000 in mid 1990. It was followed up with an A4000 which I used until around 1998. I then left the RISC OS scene. Shortly after the Raspberry Pi was introduced and RISC OS was available for it I started to play around with it again. Nothing too serious until mid last year when I decided to pick up programming again and do programming on RISC OS as well. Before I owned an A3000, me and my brother owned a BBC Micro from around 1985.

What other systems do you use?
Windows 10 PC/laptop, Apple iPad.

What is your current RISC OS setup?
RPI 2B with Pi Zero Desktop and SSD. Next to that I use emulators on Windows 10 like RPCEMU, Arculator, VA5000.

What do you think of the retro scene?
I very much love the RISCOS as well as the BBC Micro retro scene. For RISC OS for example I find it amazing what Jon Abbott has been doing with ADFFS. For the BBC Micro I’m finally able to collect programs I once only could read about and have a play with it. Some of the new software that appears for the BBC Micro is extraordinary and I find it very interesting to follow the stardot.org.uk forums with people like kieranhj, tricky, sarahwalker, robc to name but a few doing some wonderful things with the machine and making it work under emulation as well.

Do you attend any of the shows and what do you think of them?
No (not yet), but I follow the show reports via sites like Iconbar and Riscository. When available I even watch some of the show’s videos. I like it the reports/videos are online and they do give some valuable extra/background information if you’ve not been there. As well as put some faces with the names you otherwise only read about 😊

What do you use RISC OS for in 2018 and what do you like most about it?
Programming. I very much like the fact that e.g. AMCOG and Drag’nDrop programs are available and sources are “open” and thus can be studied to learn from. This and the AMCOG Dev Kit allows you to do things that normally would cost more time othwerwise. It’s is the reason why I decided to distribute the sources with the Dickie Brickie game as well, just in case…

Retro kind of things like running games and other programs. On my PC I have an application called LaunchBox which allows RISC OS and BBC Micro programs to be run with a click of a button under emulation. Software/Games that once I could only read about in the Acorn magazines of the time I’m now able to run. For some reason especially with the BBC Micro it was hard to get any software where we lived and we had to make do with programming some of it ourselves or get it by typing in from magazine listings. The latter leading me many years later to remake Dickie Brickie. Back in the day it was a lot of work to type it in, but when we ran it we finally got a glimpse what the machine was capable of with the sprites, sound and animations on display.

What is your favourite feature/killer program in RISC OS?
StrongED & StrongHelp, BBC Basic, Netsurf, ADFFS, ArcEm, BeebIt, InfoZip, AMCOG Dev Kit

What would you most like to see in RISC OS in the future?
Just ongoing developments in general like RISC OS Open is doing with some of the foundations of the system.

Favourite (vaguely RISC OS-releated) moan?
Things can always be better of course, but sometimes I’m just amazed that RISC OS is still around and actively used and developed for. For what I want to do with RISC OS currently – mainly programming – and the fact that I’m still (re-)discovering/learning things I don’t have any complaints

Can you tell us about what you are working on in the RISC OS market at the moment?
I have been working on a remake of a bbc micro game Dickie Brickie. I started remaking it using my own code, but when I learned about the AMCOG Dev Kit I switched over and rewrote most of the game. There is a really nice article on the game at the Riscository site.

Any surprises you can't or dates to tease us with?
I’m investigating a next game to program. I quite like the idea of making a platform game, but I’ve some learning to do on how to do that so it could be a while.

Apart from iconbar (obviously) what are your favourite websites?
Riscository, RISC OS Open (Forums), RISCOS Blog, DragDrop, Stardot (Forums) and some recently discovered websites on programming and game development.

What are your interests beyond RISC OS?
Programming and IT in general.

If someone hired you for a month to develop RISC OS software, what would you create?
That’s a tough question… perhaps some updates to Paint.

Any future plans or ideas you can share with us?
I would like to investigate the use of the DDE and C language.

What would you most like Father Christmas to bring you as a present?
Nothing very special comes to mind. But it would be nice if JASPP would be allowed to disctribute some more games and/or games from the past (e.g. 4th Dimension) would be more easily available.

Any questions we forgot to ask you?
No. Thank you very much for the interview!

No comments in forum

Categories: RISC OS

Acorn World at Cambridge computer museum, 8-9th Sept 2018

The Iconbar - Sat, 09/01/2018 - 01:55
Acorn World 2018
Sat 8th & Sun 9th September, 10am-5pm
@ The Centre for Computing History, Cambridge
http://www.computinghistory.org.uk/det/43277/Acorn-World-Exhibition-8th-9th-September-2018/

The Acorn & BBC User Group in association with the Centre for Computing History, Cambridge’s premier computer museum, are pleased to announce Acorn World 2018.

This exhibition will feature machines and software from across Acorn’s history and beyond, showing how they started, the innovative systems produced along the way, and the legacy of successful technology they left behind.

There will be a range of Acorn-era computers on display – and in many cases running for visitors to try out for themselves – covering everything from the System 1, through to the iconic RiscPC – which many recognise as the the pinnacle of Acorn’s computer designs – and beyond, including the never-released Phoebe, and a number of rare prototypes. The vintage displays will also include classic magazines, sure to set those nostalgic flames burning, and software which enthralled, entertained, and educated many users – and even inspired some to go into programming themselves.
Some of those classic computers have been given a new lease of life by enthusiastic users, with modern add-ons and other clever innovations – and there will be a number of these on display as well.

The exhibition doesn’t just stop at machines that came directly from the Acorn stable, though – there will also be post-Acorn systems, including the ultra-cheap Raspberry Pi and at the other end of the scale, the ‘slightly pricier’ Titanium – both of which are themselves children of Cambridge.

Tickets are only £8 for adults, £7 for over 60s, and £6 for children. This includes access to all the museum’s exhibits featuring mainframe, mini, home computers and games consoles from the past 50 years, plus the Guinness World Record holding MegaProcessor. This is a fund raising event for the museum to help continue their important work preserving and archiving computing history.

The Centre for Computing History, Rene Court, Coldhams Rd, Cambridge, CB1 3EW
http://www.computinghistory.org.uk/

No comments in forum

Categories: RISC OS

August News round-up

The Iconbar - Fri, 08/31/2018 - 07:11
Some things we noticed this month. What did you see?

DDE28c update from ROOL.

Prophet Version 3.94 and Font Directory Pro 3.23 now available from Elesar

Orpheus Internet launches a crowdfunding campaign to finance the upgrading of their services. Latest total

It is games month on RISC OS blog!

New 32bit version of Dickie Brickie now on !Store for free.

R-Comp SP12a brings DualMonitor version 5 and lots of RISC OS 5.24 software updates to TiMachine.

The ROOL TCP/IP "phase 1" bounty reaches a major milestone with a beta release of the updated AcornSSL module, supporting the modern TLS protocol instead of the old and insecure SSL protocol.

André Timmermans releases DigitalCD 3.11 and KinoAmp 0.48. The new version of KinoAmp is able to use hardware overlays for improved playback performance on machines and OS versions which support that functionality.

ADFFS 2.68 released. ROOL have also updated their website

IconBar will be running regular articles over the Autumn after a bit of a summer break. We kick off next friday with an interview....

No comments in forum

Categories: RISC OS

The state of PackMan in 2018

The Iconbar - Mon, 08/20/2018 - 20:30
In a previous article we've looked at what software is available via !PackMan. But what if you're a developer who wants to get your software listed - where do you start?

In the beginning

In the beginning there was The RISC OS Packaging Project, aka RiscPkg. Debuting in 2004, it introduced a specification for how software can be packaged under RISC OS. Packages which conform to the specification can easily be installed, updated, and uninstalled by tools (such as the original RiscPkg tool). More importantly, if a package depends on other packages, those dependencies can also be managed by the same tools, saving the user the hassle of keeping dependencies updated manually.

The package format also makes it easy to construct a searchable index of packages, aiding software discovery - something very useful in the RISC OS world, where software is typically spread out very thinly across the websites of individual authors. Furthermore, the inclusion of licensing information, and the ability to produce packages containing source code, makes it possible to produce mirrors of software without running into legal problems - something also very useful in the RISC OS world, where software can become abandoned and websites can fall offline with little or no warning.RiscPkg now

If you look around the RisckPkg website, you'll notice a few suspicious things:

I could go on, but clearly the RiscPkg website isn't in the best of shape. But, that doesn't mean that RiscPkg is dead, just that its website is poorly maintained (just like some long-forgotten areas of this site, I suspect).

In terms of bits which do work, the most important bits are likely to be the following:

  • The Policy Manual - the specification for how packages should be structured. It's not the easiest document to navigate (some hyperlinks would be nice), but without it the project would truly be dead.
  • The Subversion Server - hosting the source code for all the packages that are available directly from riscpkg.org
  • The main 'Unstable' distribution. Remember how the main 'packages' link is dead? Yeah, turns out you don't really need that. If you know how to read the distribution index file (or you have a tool which knows how to read it) you can still download all the packages.
PackMan

PackMan is for all intents and purposes the successor to the original RiscPkg tool. It's designed to work with RiscPkg packages, although it has also resulted in some improvements being made to the specification itself.

One key feature of PackMan is that it's able to merge together multiple package lists. The default configuration includes the original riscpkg.org 'Unstable' distribution, the riscos.info package list, and the RISC OS Open package lists.So how do I distribute my software via PackMan?

The PackMan website recommends that the community rallies behind ROOL's package list as a central source of packages. The ROOL wiki has a guide on how to get started.

One important thing to note is that although ROOL will host copies of your packages (avoiding your software vanishing forever when your personal website inevitably dies), there's currently no way for developers to directly upload packages to ROOL's server. Instead, you must host the packages on your own website, and have a 'pointer file' which contains an index of all those URLs (and for some reason the pointer file isn't the same as a package distribution/index file - but I digress). On a nightly basis ROOL's server will crawl all of the pointer files for the registered developers, copying new/updated packages to ROOL's server and updating the central package indices.PackMan in practice

Next time we'll be taking a look at how all this works in practice, as I attempt to bring the software on my own somewhat neglected website kicking and screaming into 2018 2004.

No comments in forum

Categories: RISC OS

Elesar releases new version of Prophet

The Iconbar - Mon, 08/13/2018 - 15:50
Hot on the heels of updating Font Directory Pro, Elesar have announced a new release of the resurrected Accounting package Prophet.

The main changes in the new releases have been to bring the software so that it runs on all modern machines with a nice set of RISC OS 4 or 5 icons and does not need Aemulor to run on 32bit. Oh, and it understands the tax system in 2018.

There is also a revised 262 page manual for the product.

Elesar has been developing quite a track record of reviving and updating old RISC OS software, and we look forward to seeing what they have planned for Prophet (and what other surprises they spring on us).

">Website link with a new license for 97.20 (Including VAT) or 68.40 for an upgrade.

No comments in forum

Categories: RISC OS

Orpheus launch crowdfunding campaign

The Iconbar - Mon, 08/06/2018 - 19:40
RISC OS friendly ISP and hosting provider Orpheus Internet have recently launched a crowd funding campaign, with the goal of helping to raise the funds needed to set up a second data centre in a new location. This new data centre will act as a mirror of their primary data centre, providing some much-needed redundancy for when things go wrong - like the incident early last month that left all of their servers unreachable for several hours, and left some systems down for a couple of days.

Setting up a second data centre is something that Orpheus have been planning for a while now, but have been struggling to find the funding for - the business doesn't have enough capital to spare, and despite recognising the plans as being sound, banks and other lenders have been unwilling to offer up any cash of their own. Last month's incident - Orpheus's only major outage in the past ten years - was enough to convince Richard that the plans for the second data centre should be kicked up a notch, hence the launch of the crowdfunding campaign.

So far the campaign has received donation pledges and long-term loan pledges totalling £3,950 out of the £15,000 goal. This is good progress, but that progress will only continue if new pledges continue to be received. If this is something you're interested in supporting, please contact Richard on 01702 462385 or via the email address crowdfunding@orpheusnet.co.uk.

No comments in forum

Categories: RISC OS

July News round-up

The Iconbar - Tue, 07/31/2018 - 06:37
Some things we noticed this month. What did you see?

Interesting debugging tool called BreakAid that hooks into the OS breakpoint system.

Review of Jason Tribbeck's game Equinox on RISC OS blog.

Elesar releases new version 3.23 of Font Directory Pro

R-Comp have announced that their new mini.m computer is available for sale, squeezing the power of their ARMX6 into a much smaller and cheaper package.

Mark will be taking a break from writing articles over the summer holiday.

No comments in forum

Categories: RISC OS

RISC OS ports website

The Iconbar - Fri, 07/27/2018 - 06:26
If you are a MacOS user, you have probably heard of MacPorts (unless you are a Howebrew fan).

RISC OS users have a similarly named website at http://www.riscosports.co.uk

This site has a good collection of software including lot of Emulators for classic consoles and machines, Games, and a selection of downloads.

There are also some programs compiled with VFP support, including Quake, POVRay and MuView.

You will also find Raspberry Pi specific items including Khronos.

Finally there are some fun little OpenGL examples and some useful resources.

Some of the software is older release (ie Vice) but the site is still being update in 2018 and there is plenty of interest to download and try.

No comments in forum

Categories: RISC OS

RiscOSM continues to expand its horizons

The Iconbar - Fri, 07/20/2018 - 06:05
We wrote previously about the welcome continued improvements in Organizer. Another application which continues to see welcome regular improvements is RiscOSM, the software which allows you to create your own maps from raw data. These can then be exported to other RISC OS applications.

You can review the version history online. The latest update is 20th June 2018. As well as lots of bug fixes, Sine Nomine continue to expand the software in two key directions.

Firstly the software features allow you to do more and more with the maps. A highlight of the recent Wakefield show was watching the enthusiastic demonstration of the new editor features for changing paths.

Secondly, a map creation program is only as good as the raw data it is able to use. There is now a large range of data available for use covering not just UK but large parts of Europe, America and Australia. The software now also offers integration to some online photo resources.

It is great to see the software continuing to evolve, and we look forward to seeing what Sine Nomine will be showing at the next Show.

RiscOSM website

No comments in forum

Categories: RISC OS

Font Directory Pro moves to 3.23

The Iconbar - Fri, 07/13/2018 - 05:44
Elesar have released an updated version of Font Directory Pro. As the version number suggests, this is just an incremental update. It does add one really useful feature (suggested by a user) to allow text on the global clipboard to be used in the application.

It is good to see the software being updated, and Elesar are always keen to hear if you have any other ideas for improving the software.

The update is free to existing users (you should have received an email if you are registered) and can be purchased online

No comments in forum

Categories: RISC OS

CashBook and other goodies

The Iconbar - Fri, 07/06/2018 - 05:55
Steve Fryatt is a well-known face in the RISC OS world and a regular fixture at RISC OS shows where his stand always has lots of interesting software.

His website hosts lots of free software including the free home accounts software CashBook. This has recently reached release 1.41

There are utilities like Locate, PrintPDF and PS2Paper, lots of games.

If you are looking to write your own software, there are Build Tools and a guide to Wimp Programming In C

Steve also has some interesting pages on his website on his non-RISC OS activities.

Steve Fryatt's website

No comments in forum

Categories: RISC OS

Subscribe to Spellings.net aggregator - RISC OS