Planet Smalltalk

May 24, 2017

Torsten Bergmann - TDD example in Pharo

Self Blogs - Self “Mandarin” 2017.1

It’s been a while since we did a proper release of Self – too long in fact.

The last duck themed release was “Mallard” a couple of years (!) back – we’re overdue for more ducks so here is a new release of Self brought to you by this beauty:

320px-Aix_galericulata_(Male),_Richmond_Park,_UK_-_May_2013

Self 2017.1 is downloadable for Linux x86 (.zip) and MacOS (.dmg), or you can build it yourself from the GitHub source tree.

There is also a handbook included and available to read online.

A brief change log is:

New features:

  • Changed to new versioning system for key subsystems (vm, core, morphic, outliners)   and for release as a whole.
  • New `about` object accessible from main menu with system info.
  • New `preferences` object allows easy access to system preferences.
  • ew themeing system for outliners and a new look.
  • Extensive reorganisation of object categories in `globals` to make global objects more easily discoverable and understandable.
  • New option on `worldbuilder.self` script to allow for fully automated building of Self worlds by setting subsystem options on command line.
  • New string helper methods: `splitOn:`, `joinUsing:` and `slice:`.
  • The `transporter` is now aware of code being in multiple independent trees, not  only one single Self tree, allowing for separate projects to be kept in separate   version control repositories.
  • A system-wide logger has been included to standardise logging practices within    Self.

Updates:

  • Self Control.app on macOS updated to work with El Capitan.

Fixes:

  • Fix on macOS to reduce CPU usage when idle.
  • VM build will now explicitly show which macOS SDK it is using.
  • ^D (EOF) handled correctly at prompt
  • Fix to bug preventing compilation on recent GCC
  • Many other misc fixes.

Documentation:

  • General improvements to Self handbook.
  • Self website moved out of main repository.

Other:

  • Webserver moved to separate repository: github.com/russellallen/self-webserver
  • travis-ci.org integration for VM building

May 23, 2017

Torsten Bergmann - Things people built with Smalltalk

Juan Vuletich from Cuis Smalltalk is working at Satellogic company (Buenos Aires).  Back in 2013 the company launched "Captain Beto" (a.k.a. CubeBug-1), the first Argentine CubeSat.

Now as one of the earth-observing companies who push for more-advanced science satellites they were mentioned also in this article from nature.com. Nice.

Juan helped design and build the hyperspectral cameras in satellites Fresco and Batata. And he wrote the geometric and spectral processing software. The geometric software (image rectification and correction), the most complex part of the processing, was written by him in Cuis Smalltalk, and runs in a Cuis Smalltalk + OpenCL application.

Always interesting to see where Smalltalk is used and what kind of things people built with the help of Smalltalk

Pharo Weekly - JPMorgan open position at London

Torsten Bergmann - Fog - blockchain client for Pharo

Fog is a library that allows the user to connect to an ethereum based blockchain data base. Code is here and the original announcement is here.

Torsten Bergmann - DataFrame class -

Oleksandr Zaytsev released "Public Interface for DataFrame class" - an article on a DataFrame class to handle tabular data in Pharo.

Torsten Bergmann - Storiefied PharoDays 2017

A storified version of Pharo Days 2017 (based on tweets) is available here.

Torsten Bergmann - Updated Refactoring browser critics rules in Pharo

Myroslava is working on rewriting the refactoring browser critics rules from Pharo into newer rules, in a more comprehensible format. Initial version is on her GitHub account - there is a description of the work as an article on Medium

Torsten Bergmann - Commander: command pattern library for Pharo

Commander is a new Pharo library which models application actions as first class objects. Description is here and code is on SmalltalkHub.

Torsten Bergmann - Calypso presentation PharoDays 2017

Calypso browser is a new browser for Pharo that also allows remote debugging. A presentation from PharoDays 2017 is here

May 22, 2017

Torsten Bergmann - Beer and Smalltalk meeting

Torsten Bergmann - Berlin Smalltalk meeting

There is a Smalltalk user meetup in Berlin, germany 12th of June. Read more.

Torsten Bergmann - Lawsuit tracker

Torsten Bergmann - Hash ID's for Pharo

A Smalltalk implementation of Ivan Akimov's Hashids to obsfuscate internal ids and references. Read more here

May 21, 2017

Pierce Ng - Seaside and Pharo 5

I just tried loading Seaside into the latest Pharo 6 pre-release image from the Catalog Browser. It loads cleanly. However, the Seaside control panel doesn't start because it uses NewListModel which does not exist in this image:

WAPharoServerAdapterSpecBrowser>>#initializeWidgets

  self instantiateModels: #(
    listModel NewListModel "<== Exists In Pharo 5, not in Pharo 6"
    textModel TextModel
    toolbarModel WAServerAdapterToolbar).

Ok, how about Pharo 5? Using Pharo 50772, which is currently the latest Pharo 5 image, I loaded Seaside 3.1.5 programmatically after visually inspecting ConfigurationOfSeaside3:

Gofer it 
  smalltalkhubUser: 'Seaside' project: 'Seaside31';
  package: 'ConfigurationOfSeaside3';
  load.
(#ConfigurationOfSeaside3 asClass project version: '3.1.5') load.

The load sequence includes messages to String>>#subStrings: which is deprecated. The senders are GRStringTest>>#testSubStrings, JQAjax>>#callback:passengers:, WAAdmin class>>#register:at:in: and WAAdmin class>>#unregister:in:.

Otherwise Seaside 3.1.5 loads cleanly. Test Runner reports 1173 run, 1171 passes and 2 expected failures.

May 19, 2017

Pharo Weekly - Chrome DevTools Protocol and Pharo

Hi,

I played around with remote controlling Google Chrome from
Pharo using Chrome DevTools Protocol [1] (based on WebSockets).

The video shows an example using latest Pharo 6 on Mac:

Initial Code is on GitHub [2] if someone is interested,
requires OSOSX and Zinc Websockets to be loaded.

Have fun
T.

[1] https://chromedevtools.github.io/devtools-protocol
[2] https://github.com/astares/Pharo-Chrome


May 18, 2017

Torsten Bergmann - Chrome DevTools Protocol and Pharo

I played around with remote controlling Google Chrome from Pharo using Chrome DevTools Protocol (based on WebSockets).

The following video shows an example using latest Pharo 6 on Mac:


Initial Code is on GitHub if someone is interested, requires OSOSX and Zinc Websockets to be loaded.

Torsten Bergmann - Pharo Days 2017

May 16, 2017

Cincom Smalltalk - Smalltalk Digest: May Edition

The May Edition of the Cincom Smalltalk Digest.

The post Smalltalk Digest: May Edition appeared first on Cincom Smalltalk.

Torsten Bergmann - German election and Smalltalk

German election results are displayed with an application powered by Gemstone/S Smalltalk. Read more

Marten Feldtmann - Gemstone/S Application Example – HbbTV Playout System

The last two weeks we had two elections here in Germany – one in Schleswig-Holstein and last weekend in Nordrhein-Westfalen in Düsseldorf.

Television Tower next to state parliament in Düsseldorf

As mentioned in an earlier posting we already used Gemstone/S as our database during the election for the broadcaster SWR and we played out results and graphics for an internet based application. The model is defined using PUM, source code is created for Topaz, Sencha ExtJS and Python3.

This weekend we did a similar application for the broadcaster WDR (Westdeutscher Rundfunk), but not for their Internet presence, but for an HbbTV hybrid add-on service during their program on sunday and 14 days later (so its still available via their WDR TV channels).

Persons at the broadcaster were able to enter results via an browser based data-enter application – and the results were stored in Gemstone/S and transferred to the system producing the animated TV graphics. Application as usual – API oriented, browser based.

Input Application written in Sencha ExtJS

The structure of the application was pretty similiar to the one of last autumn – main logic is located in the Gemstone/S database, several independent topaz processes are inserting election results, preparing graphical repesentations of the results and even do an automatic publication of the results without interaction.

The system is managed via a browser based UI (written in Sencha ExtJS), communicating via an API with the database. External applications were otherwise written in Python3.

Management Software written in ExtJS

The system was actually running in parallel on two different systems at some hosters – producing the same results independently.

Current HbbTV at the WDR television broadcaster

The end-user application (running on the TV sets) was written in “low-level” Javascript (WITHOUT any larger libraries like jQuery) to make is runnable on even the most slowest TV set available on the market :-)))

Final Results shown in HbbTV

Voters moving from one party to another


Filed under: Smalltalk Tagged: elections, Gemstone/S, HbbTV, Javascript, PUM, WDR

Smalltalk Jobs - Smalltalk Jobs – 5/16/17

Three jobs in Germany, all of them with pension management firms.

The first two are in Cologne.

The first is with PSVaG they are looking for Smalltalk with complex analysis, and, good team work.

The second is with collogia AG and they want Basis and Visual Works Smalltalk.

The last job is in Berlin and it is with Verka VK which is the largest pension company in Germany.

Good luck with your job hunt!

 


Filed under: Employment

Cincom Smalltalk - Using Polycephaly/MatriX in Cincom Smalltalk™

A Product Management Mini Survey The purpose of product management mini surveys is to make sure that we communicate, listen and understand customer and user requirements, needs and issues. Polycephaly […]

The post Using Polycephaly/MatriX in Cincom Smalltalk™ appeared first on Cincom Smalltalk.

May 15, 2017

Smalltalk Jobs - Reducing the friction when upgrading: Change Type Filtering for the Package Comparison Tool

Many of you that follow this blog are, or will be involved in projects that require upgrading applications from one version of Smalltalk to a newer one. Those upgrades can often be difficult, particularly when there are multiple versions being skipped.

As part of the Support team at Cincom®, I and my teammates are often called on by our customers to be the “first responders” when large obstacles get in the way during an upgrade.

Based on feedback from our customer’s experiences, I have created enhancements to the Package Comparison tool that I hope will reduce some of the friction involved in upgrading VisualWorks® and ObjectStudio® applications. Please follow the links below for full details about this new Contributed Pacakge.

Introducing Change Type Filtering for the Package Comparison Tool

When loaded, this package adds three Checkboxes to the Package Comparison Tool that allow the user to control what types of comparisons are to be shown or hidden. It is designed to work with ObjectStudio 8.4 or Cincom VisualWorks 7.9 and above. When any of the new options are turned on (checked), the comparison view will be updated so that those types of comparisons are no longer shown. The hidden comparisons can be shown again by turning off any of the options (unchecking a checked option).

A video demonstrating the Contributed package is also Available.

Good luck with your upgrades,
James T. Savidge

View James T. Savidge's profile on LinkedIn

This blog’s RSS Feed


Filed under: Employment

Smalltalk Jobs - Smalltalk Jobs – 5/15/17

  • Fremont, CASoftware Engineer 3 (42681) at Lam Research
    • Required Skills:
      • B.S or Masters in Computer Science, Computer Engineering, Electronics or related field
      • Knowledge of embedded software development and design
      • Knowledgeable with communication protocols such: I2C, SPI, UART etc.
      • Excellent knowledge of Object Oriented Software implementation and design e.g.: Design Patterns and Finite State Machines
      • Strong software engineering skills: modular design, data structures and algorithms
      • Experience with Source Control and Development life cycles
      • Analytical approach to root cause analysis
      • Knowledge of multithreading is a must (preemptive thread scheduling)
      • Understanding of Networking/TCPIP
      • Ability to travel within USA, Europe, and Asia (total is less than 10%)
    • Wanted Skills:
      • Background in electronics and electrical engineering
      • Smalltalk experience
      • Experience with real-time operating systems
      • Experience in distributed embedded controls systems
  • Jersey City, NJSmall Talk Developer through VDart
    • Required Skills:
      • Extensive working experience in Smalltalk Language using IBM Visual Age Smalltalk, ObjectStudio, Visual Smalltalk and VisualWorks Smalltalk
      • Experience in developing the Enterprise Applications using Java, Struts, EJB, JDBC, JavaBeans, Java Servlets, JSP, JavaScript, HTML, XML
      • Possess excellent technical, management, leadership, coordination, communication, negotiation and intra personal skills.
  • Minneapolis, MNSmalltalk Technical Lead through Cognizant
    • Required Skills:
      • Candidate should have Minimum 8+ years of Software Programming experiences in Smalltalk technology (Ex: Smalltalk, Sybase)
      • Development and Support experience
      • Tech lead experience
      • Hands on experience of Development / test/ Deploy
      • Experience in working with global teams
      • Fluent English language skills (written, spoken)
    • Wanted Skills:
      • Experience in on-site / off-shore delivery model
      • Experience & knowledge in Commodity Trading, Risk Management (market risk, credit risk), ERP, Financial Services
    • Additional listings: Smalltalk Technical Lead
  • Columbus, OHVisualAge SmallTalk Developer through ReqRoute
    • Required Skills:
      • VisualAge Smalltalk
      • DB2
      • MQ Series
      • At least 4 years in Analysis, Designing, Development , Testing and Supporting of projects involving Smalltalk.
    • Wanted Skills:
      • Experience in handling Application development and Application support projects.
      • Experience of working in Onsite/Offshore model
      • Utility domain or experience working with Billing Applications in Telecom/Finance domain
  • Richland, WABWR Neutronics Reload Design & Analysis Engineer I-III-DES02320 (Multiple positions are available) at AREVA Front End Business Group
    • Required Skills:
      • Engineer II: BS in Nuclear Engineering plus 2-3 years experience reactor physics or fuel management engineering experience. An advanced engineering degree may be substituted for related work experience (MS 1-2 yrs. or PhD 1-3 yrs.)
      • Engineer III: BS in Nuclear Engineering plus 3-5 years experience reactor physics or fuel management engineering experience. An advanced engineering degree may be substituted for related work experience (MS 1-2 yrs. or PhD 1-3 yrs.)
      • Engineer IV: BS in Nuclear Engineering or related field plus 5-7 years experience reactor physics or fuel management engineering experience. An advanced engineering degree may be substituted for related work experience (MS 1-2 yrs. or PhD 1-3 yrs.)
      • Basic experience and capabilities with MICROSOFT Office software products (WORD, EXCEL, etc.).
      • Must have a pro-active approach to problem identification and resolution.
      • Must have ability and attitude to learn a variety of new procedures, processes, and tools, while maintaining various stages of production.
    • Wanted Skills:
      • A wide range of other skills related to the position, including Smalltalk
Good luck with your job hunting,
James T. Savidge

View James T. Savidge's profile on LinkedIn

This blog’s RSS Feed


Filed under: Employment Tagged: jobs, Smalltalk, Smalltalk jobs

May 14, 2017

Torsten Bergmann - Pharo booklet collection

Pharo now has a booklet collection. Check it out on the books page.

Pharo Weekly - New booklet: Voyage :)

A new booklet is joining the collection and it is on Voyage the object to document mapper developed by E. Lorenzano.

Available in beta http://files.pharo.org/books/ and open to contributors at https://github.com/SquareBracketAssociates/Booklet-Voyage

Enjoy

Stef


Stefan Marr - A 10 Year Journey, Stop 3: Performance, Performance, and Metaprogramming

The third post of this series is about how I started using Truffle and Graal, pretty much 4 years ago. It might be in parts ranty, but I started using it when it was in a very early stage. So, things are a lot better today.

Concurrency needs Performance, usually

As mentioned in the last post, the result of my PhD was an ownership-based metaobject protocol that is meant to enable VMs to support a wide range of different concurrency models. The major problem with the approach, and also my evaluation, was that I couldn’t show that it is practical. The RoarVM is a simple bytecode interpreter, and the literature on compiling and optimizing metaobject protocols talked only about static systems with restrictions that would make the ownership-based MOP impossible. Worse, MOPs were kind of abandoned by the research community, because performance was an issue. Many researchers moved on to aspect-oriented approaches, at least in part, because aspects are applied more targeted and thus, incur less general overhead than MOPs.

A hard problem, abandoned for 20 years, and nobody really interested in it anymore? Pretty much sounds like it’s a stupid idea, right? It probably was, and perhaps still is. But concurrency researchers typically want to show that their techniques are useful for performance critical applications. And, I wanted to do that, too.

How to get a fast VM?

So, I needed a new platform for my research. One option would have been to take the RoarVM all the way. Build a state-of-the-art JIT compiler for it. Another would be to apply the ideas of the RoarVM to the CogVM and improve its JIT compiler. But building another JIT compiler? That’s a huge undertaking. Would probably take a few person years to get anywhere useful. And, while I am curious about compilers, I am not really seeing myself building more than a baseline JIT compiler.

But what other options do we have? RPython is a pretty interesting project. It promises you a meta-tracing JIT compiler for your simple interpreter. Sounds great. But there’s a catch: RPython doesn’t really have a concurrency story compatible with my goals. There’s a bit of experimenting with STM going on, but no decent shared-memory GC.

And then, there was that Truffle thing, colleagues from Oracle Labs kept talking about. It was just released as open source at that point. Truffle promised that simple AST-based interpreters combined with partial evaluation would run applications as fast as Java on a JVM. Sounds great. And, the JVM got everything I need for my research, too.

TruffleSOM: The first steps with a simple Smalltalk on top of Truffle

Truffle it is, I thought, and started implementing the little Smalltalk I had been toying around with in 2007 on top of it. There was already a Java version, simply called SOM. So, how hard could it be?

Well, turns out, much harder than expected. Me being not really a compiler person, I had no intuition for how partial evaluation would work on my interpreter. And as a testament to how hard it was for me, apparently even to this date, I am third in the ranking of who spammed the graal-dev mailing list most.

I suppose there were three important reasons for it. As I mentioned before, I had no intuition of how the partial evaluation really works, and what kind of optimizations I can expect from the systems. The second reason was that I did not really have access to the expertise. Mailing lists are fine but slow. And people need to be willing to take the time to answer. So, during my endeavor of building a fast Smalltalk, the most helpful conversations were actually in person at conferences with people from the Truffle team, or when I actually got the chance to visit them in Linz. And the third reason, which is fixed by now, was the overall stability of the system. To me it was very surprising that I ran into many bugs in Truffle and the Graal compiler. I could somehow not really believe that the Truffle team didn’t encounter those issues with their JavaScript and Ruby implementations. But as it turns out, each new language implementation does things somewhat different and the languages are just different enough to trigger new edge cases that haven’t been considered before. As far as I know, there is still a little of that happening today with Graal. Every new language leads to one or two bugs being discovered that none of the previous languages hit.

How can this be sooo hard???

All in all, my experience to build a new language with Truffle and Graal was far from pleasant. On the contrary, it was frustrating. I often just didn’t have the knowledge to debug problems myself. And the Truffle team didn’t really have time to teach an outsider all those basics.

So, yeah, I was very close to throwing in the towel. Well, I actually kind of did. At least a little. There was a moment of “fuck this, how can it be so hard? screw Truffle! Let’s look into RPython!”

And PySOM was born. PySOM is a literal port of the SOM bytecode interpreter to Python. SOM is really a simple and small language. If you know what you’re doing, and can type reasonably fast, you can implement it in 3 or 4 days in a new language.

PySOM was the first step. The next step was RPySOM: a port from Python to RPython, which is the Python subset that the RPython toolchain can compile statically into a fast interpreter with a meta-tracing JIT compiler. This experience was sooo much more pleasant. One big reason was that the PyPy+RPython community uses an IRC channel for communication and was super friendly and happy to help with all my problems. Another reason was that I knew Carl Friedrich, one of the PyPy people already for a while, and he guided me through the classic pit falls. And, I suppose, RPython at that point was already much more mature than Truffle used to be. So, fewer crashes, and I think, I didn’t really trigger much bugs in RPython either. And, since it is a trace-based compiler, understanding what the optimizer did was also much easier, because the result mapped much more directly back to the input code of the interpreter than with a fancy graph-based compiler IR. So, yeah, RPySOM was born, and with that additional knowledge, I kind of managed to make TruffleSOM a reality, too.

Some of this story, and what we learned was written down in the Are We There Yet? article.

And Finally, Fast Metaprogramming!

Then it was time to get back to my original problem: how do I get my ownership-based metaobject protocol fast? Well, turns out if you got a fancy JIT compiler, the solution is pretty simple and already existed in other Truffle interpreters: dispatch chains. Dispatch chains are essentially lexical caches for dispatch operations. A generalization of polymorphic inline caches if you will.

Together with Chris Seaton, we published a paper on Zero-Overhead Meta Programming, where we were able to show how all kind of reflective operations can be made fast, and were I was finally able to show that my metaobject protocol can be realized without sacrificing performance.

A bit later, I also wrote up a longer paper comparing meta-tracing and partial evaluation in more detail.

Cutting a long story short: nothing is as easy as it sounds. In total, it took me two years to go from a simple Smalltalk AST interpreter to a system that can take on Java. But, things should be better today. When starting to implement a new language with Truffle, there are now a few tutorials, and other resources, and the platform is much more mature and pleasant to use!

Next week, I might take a break from this series, but there are at least two more posts coming:

  • Concurrency and Tooling, or ‘What is project MetaConc?’
  • and, Growing the SOM Family

May 13, 2017

Pharo Weekly - Pompeii Volcanic Graphics, a mesh based 2D graphics API

Hello,

I am releasing a first version of a new 2D graphics API that I am making for Pharo, using OpenGL.

unnamed.png
http://smalltalkhub.com/#!/~ronsaldo/PompeiiGraphics
https://youtu.be/emE6_1RpAo8

This 2D graphics API is not vectorial based becase it does not use SVG style paths. This API is triangle mesh based, so it is more friendlier with the GPU than Athens or Sparta.

With this API I did a basic gui toolkit, with only two widgets: buttons and label. I did this Widget toolkit to not mess with Bloc, and because I need something relatively stable for the Woden 2 level editor. For now, I am leaving this widget toolkit mostly as a demo. Hopefully it is possible to make Bloc backend using this API.

During the process of making this API, I had to fix several bugs with OSWindow, and bugs in the interaction between OSWindow and OpenGL. The biggest problem was a race condition between the creation of an OSWindow using SDL2, and the events (such as Expose) that are sent to the just created Window.

As for Mac OS X, OSWindow is out of service until a pull request ( https://github.com/OpenSmalltalk/opensmalltalk-vm/pull/138 ) gets integrated into the VM.

Best regards,

Ronie


May 12, 2017

Smalltalk Jobs - Smalltalk Jobs – 5/12/17

Yesplan is looking for a new colleague to join the software engineering team.
The position is required to be full-time and on-site in Gent, Belgium.
Do you fancy working with Pharo and GemStone/S but also with Javascript / ReactJS and other technologies to build intuitive event venue management software?
Read our vacancy in the link below and let me know!