Planet Smalltalk

January 18, 2017

Cincom Smalltalk - Smalltalk Digest: January Edition

The January Edition of the Cincom Smalltalk Digest.

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

January 17, 2017

Joachim Tuchel - Camp Smalltalk Durham/Raleigh March 2017

Instantiations, Inc. just announced they are sponsoring a Camp Smalltalk at Durham, North Carolina March 31st – April 2nd, 2017. You wonder what a Camp Smalltalk is? Well, that’s easy, let me explain to you: A few hands full of Smalltalk debvelopers, enthusiasts and also interested newbees meet for a few days at a nice… Continue reading Camp Smalltalk Durham/Raleigh March 2017

ESUG news - [ANN] Camp Smalltalk In Raleigh NC

Instantiations is sponsoring a Camp Smalltalk In Raleigh NC the end of March.

We would like to invite you to Camp Smalltalk - RDU, March 31st – April 2nd 2017 in downtown Durham, North Carolina. Event details and registration info are available at http://www.campsmalltalk-rdu.com.

Hope to see you there!

January 13, 2017

Pharo Weekly - Pharo deployed with Snapcraft

Hi all,

Just wanted to share this:
It is basically the code to generate a snap package of the pharo-vm using snapcraft. Using this, the VM is generated and packaged with all dependencies. This should help in running pharo in different linux distributions.
I invite you to check it, report problems and submit fixes.
Cheers,
Guille

Cincom Smalltalk - The Stack Overflow 2017 Survey Is Now Open!

Two years ago, I noted that Smalltalk was not represented in the annual Stack Overflow developer survey, and committed to try and change that. We were partly successful – Smalltalk […]

The post The Stack Overflow 2017 Survey Is Now Open! appeared first on Cincom Smalltalk.

Torsten Bergmann - Calypso browser update: method browser and better UI

A new version of Calypso, a new browser for Pharo. Read more here and here or watch the new video:


Torsten Bergmann - Snapcraft for Pharo

With snapcraft.io you can package any app for every Linux desktop, server, cloud or device, and deliver updates directly. Guillermo provided a Snapcraft for Pharo today.

Torsten Bergmann - CampSmalltalk 2017 in Durham, North Carolina

You're invited to Camp Smalltalk - RDU, March 31st – April 2nd 2017 in downtown Durham, North Carolina. Details at http://www.campsmalltalk-rdu.com

January 12, 2017

Cincom Smalltalk - An Invitation to Camp Smalltalk – RDU

Camp Smalltalk – Raleigh/Durham (aka Camp Smalltalk – RDU) will be held in downtown Durham, North Carolina on March 31 – April 2, 2017.

The post An Invitation to Camp Smalltalk – RDU appeared first on Cincom Smalltalk.

January 10, 2017

Stefan Marr - Communicating Sequential Processes for Newspeak/SOMns

One possible way for modeling concurrent systems is Tony Hoare’s classic approach of having isolated processes communicate via channels, which is called Communicating Sequential Processes (CSP). Today, we see the approach used for instance in Go and Clojure.

While Newspeak’s specification and implementation come with support for Actors, I want to experiment also with other abstractions, and CSP happens to be an interesting one, since it models systems with blocking synchronization, also know as channels with rendezvous semantics. I am not saying CSP is better in any specific case than actors. Instead, I want to find out where CSP’s abstractions provide a tangible benefit.

But, the reason for this post is another one. One of my biggest quibbles with most CSP implementations is that they don’t take isolation serious. Usually, they provide merely lightweight concurrency and channels, but they rarely ensure that different processes don’t share any mutable memory. So, the door for low-level race conditions is wide open. The standard argument of language or library implementers is that guaranteeing isolation is not worth the performance overhead that comes with it. For me, concurrency is hard enough, so, I prefer to have the guarantee of proper isolation. Of course, another part of the argument is that you might need shared memory for some problems, but, I think we got a more disciplined approach for those problems, too.

Isolated Processes in Newspeak

Ok, so how can we realize isolated processes in Newspeak? As it turns out, it is pretty simple. Newspeak already got the notion of values. Values are deeply immutable objects. This means values can only contain values themselves, which as a consequence means, if you receive some value from a concurrent entity, you are guaranteed that the state never changes.

In SOMns, you can use the Value mixin to mark a class as having value semantics. This means that none of the fields of the object are allowed to be mutable, and that we need to check that fields are only initialized with values in the object’s constructor. Since Newspeak uses nested classes pretty much everywhere, we also need to check that the outer scope of a value class does not have any mutable state. Once that is verified, an object can be a proper deeply immutable value, and can be shared with out introducing any data races between concurrent entities.

Using this as a foundation, we can require that all classes that represent CSP processes are values. This gives us the guarantee that a process does not have access to any shared mutable state by itself. Note, this is only about the class side. The object side can actually be a normal object an have mutable state, which means, within a process, we can have normal mutable state/objects.

Using the value notion of Newspeak feels like a very natural solution to me. Alternative approaches could use a magic operator that cuts off lexical scope. This is something that I have seen for instance in AmbientTalk with its isolates. While this magic isolate keyword gives some extra flexibility, it is also a new concept. Having to ensure that a process’ class is a value requires that its outer lexical scope is a value, and thus, restricts a bit how we structure our modules, but, it doesn’t require any new concepts. One other drawback is here that it is often not clear that the lexical scope is a value, but I think that’s something where an IDE should help and provide the necessary insights.

In code, this looks then a bit like this:

class ExampleModule = Value ()(
  class DoneProcess new: channelOut = Process (
  | private channelOut = channelOut. |
  )(
    public run = ( channelOut write: #done )
  )
  
  public start = (
    processes spawn: DoneProcess
               with: {Channel new out}
  )
)
So, we got a class DoneProcess, which has a run method that defines what the process does. Our processes module allows us to spawn the process with arguments, which is in this case the output end of a channel.

Channels

The other aspect we need to think about is how can we design channels so that they preserve isolation. As a first step, I’ll only allow to send values on the channel. This ensure isolation and is a simple efficient check whether the provided object is a value.

However, this approach is also very restrictive. Because of the deeply immutable semantics of values, they are quite inflexible in my experience.

When thinking of what it means to be a value, imagine a bunch of random objects: they all can point to values, but values can never point back to any mutable object. That’s a very nice property from the concurrency perspective, but in practice this means that I often feel the need to represent data twice. Once as mutable, for instance for constructing complex data structures, and a second time as values so that I can send data to another process.

A possible solution might be objects with copy-on-transfer semantics, or actual ownership transfer. This could be modeled either with a new type of transfer objects, or a copying channel. Perhaps there are other options out there. But for the moment, I am already happy with seeing that we can have proper CSP semantics by merely checking that a process is constructed from values only and that channels only pass on values.

Since the implementation is mostly a sketch, there are of course more things that need to be done. For instance, it doesn’t yet support any nondeterminism, which requires an alt or select operation on channels.

Torsten Bergmann - Pharo on FOSSASIA 2016

A journey in FOSS with Pharo & FOSSASIA by Jigyasa Grover - FOSSASIA 2016

January 09, 2017

ESUG news - UK Smalltalk User Group: Monday, January 30th

The first 2017 meeting of the UK Smalltalk User Group Meeting will be on Monday, January 30th.

We'll meet at our usual venue The Counting House (http://www.the-counting-house.com/) at 7pm.

If you'd like to join us, you can just show up at the pub. You can also sign up in advance at the meeting's Meetup page: https://www.meetup.com/UKSTUG/events/236496717/ .

Smalltalk Jobs - Smalltalk Jobs – 1/8/17

  • Whitehouse Station, NJSmallTalk Developer through Net2Source
    • Required Skills:
      • Extensive working experience in Smalltalk Language using IBM Visual Age Smalltalk, ObjectStudio, Visual Smalltalk and VisualWorks Smalltalk
      • Possess excellent technical, management, leadership, coordination, communication, negotiation and intra personal skills.
      • Experience in developing the Enterprise Applications using Java, Struts, EJB, JDBC, JavaBeans, Java Servlets, JSP, JavaScript, HTML, XML
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

January 08, 2017

Pharo Weekly - A little expression interpreter

I released a version of a little expression interpreter for the new book: Object-oriented programming and design with Pharo.

https://ci.inria.fr/pharo-contribution/view/Books/job/LearningObjectOrientedProgramming/63/artifact/book.pdf

Typos are welcome as pull requests.

Stef


January 07, 2017

January 03, 2017

Pharo Weekly - Under the cover of the bootstrap

Guillermo P. one of the lead bootstrapper with Pavel. K and C. Demarey explained the under the cover decisions made around the Pharo 7.0 bootstrap…

Is there a scope and purpose statement for the bootstrap somewhere?

Not writen that I know of. Maybe we should do it. But from many discussions here in the team I’d define the pharo bootstrap as a pharo environment that is
– minimal (in the sense that it keeps only stuff required to run)
– clean (in the sense that there is the less dead code and dead dependencies as possible)
– and is able to grow (in the sense that you can install new code on it). Think that Pharo is not just the bootstrap. People will not accept a Pharo without a development environment, without a debugger or a workspace.

These three points are a long term goal I woud say, and particularly the last point is in big conflict with the first one. You can have an image that executes code but has no compiler for example.
So making a trade-off but always going towards that goal, what we decided with Christophe one year and a half ago to:

– select a minimal set of packages that would belong to the bootstrap image
* To run, you need the Kernel.
* To be able to install new code you need some kind of I/O and some way to transform the input as classes/methods. Thus we chose to put also basic command line handlers, files, and the compiler. We discussed about putting a flavour of Fuel (say Tanker) instead of the compiler, but Tanker was not stable as it was only experimental and nobody used it for real; the compiler was much more stable as we use it everyday; and besides, Tanker was depending on the class builder, so it only allowed us to remove the compiler but not the class builder.
* To be clean, we started looking at the dependencies of those packages.
– We finished in a selection of about 53 packages. Remember that Pharo itself has nowadays around 464 packages…
RPackageOrganizer default packages size “464”
So this was as good as a ~10% of the original image. Good enough to have a first version.

– And we started working on dependency analyses on them. The following report made by Christophe lists all the bootstrap packages and their dependencies, and reports when a new dependency is introduced.

https://ci.inria.fr/pharo/view/6.0-Analysis/job/Pharo-6.0-DependencyAnalysis/Dependencies_HTML_Report/

See what the dependency graph looks of the bootstrap

https://ci.inria.fr/pharo/view/6.0-Analysis/job/Pharo-6.0-DependencyAnalysis/Dependencies_HTML_Report/

and extrapolate to the entire image :).
And that, after we worked a LOT to cut off/separate/untangle/decouple those 53 packages from the rest, rewrite parts of the system (a big example of it is the SessionManager).
Now, this is of course not the end. There are still lots of things to do.

– the kernel can be still cleaned up even more
– we could implement some sort of binary serializer specialized for classes and methods to shrink even more the bootstrap
– the rest of the image has still to be cleaned. Nowadays on top of the bootstrap Monticello and Metacello are bootstrapped using manual a approach and afterwards, the rest of the image is loaded by using a Baseline

https://github.com/guillep/pharo-core/tree/66666949ceffbd806ff39188548d65797a1e8314/src/BaselineOfUI.package

That baseline can be enhanced, splitted in smaller baselines. This require non-bootstrap packages to be revisited, have checked their dependencies and so on…

So what you see in that list is the result of several decisions and a lot of work. And the focus was to release something and not die in the process. Hope that answers the question (I will copy past this and put it into some wiki btw)

Guille


January 02, 2017

December 30, 2016

Torsten Bergmann - Redline Smalltalk updated

Redline Smalltalk (which is running on JVM) was updated. Read more.

December 29, 2016

Francois Stephany - Android Things

Google announced the developer preview of Android Things. You have maybe heard about Brillo last year without knowing what it really was. The promise was so vague and abstract that nobody really cared (at least in my circles). With Android Things the promise is clearer. The big title on the project homepage says:

The ease and power of Android If you can build an app, you can build a device

It means that you can leverage your experience and tools to develop products. If you've already built android apps you'll be at home. You can reuse Android Studio, reuse your existing Java code and deploy this to a device with or without a screen.

Good enough

But was is the difference with the myriad of other products in the market? It's very easy to boot a Raspberry Pi, write some Python code and control the GPIOs to drive almost everything. The hobbyists already have all the tools they need to tinker and to build something useful.

When targeting Android Things, a developer can prototype on a board and easily deploy on another one. It seems that Google has certification process for Android Thing. Switching the underlying hardware and reuse the code is already possible with other OS of course but certified boards/microprocessors could greatly improve the experience.

Unless an hobbyist is a hardcore android developer there is proably not a lot of reason to pick Android Thing for your next project. Setting up the Android SDK, learning Android Studio and all the associated tools (e.g., adb, logcat) is not straightforward if you are doing it for the first time. It's probably faster to connect a screen, keyboard and mouse on your Pi and start coding.

Updates

In an industrial setting the requirements are quite different. Processes are in place and you want to leverage battle tested tools. Products can have a very long lifetime, 10-20 years is common and you might need to mass produce them. If the business is not life critical, a Raspberry Pi and your code on it is probably enough. If the product is connected to the internet, you must be much more careful about what you do and you should have a transparent update mechanism to upgrade the device remotely. Beware that this update mechanism can also be abused to compromise the deployed devices. This really is a nightmare today.

In the eve of 2017, automatic and transparent updates are vital. This year, we've seen a lot of security issues from companies selling IoT devices in the fire and forget style. Consumers don't realise that their connected lightbulbs, coffee maker and fridge are actually dangerous items that can be used in huge Denial of Service attack. Manufacturers have no incentives to level up their security and update practices.

Updating the OS running the devices is critical. Software companies are working hard to make this easier for developers and product manufacturers. For example, Canonical builds Ubuntu Core which provices a foundation on which products can be built. This is also where Android Things can shine. It is still vaporware but Google announced that they will provide the infrastructure to remotely update deployed devices. If done well, this could be a huge win as it would remove the burden that is currently imposed to product manufacturers. It also means that a product now relies on Google's goodwill. If they shut down the service, you're screwed.

Locked OS

With Ubuntu Core, you have complete freedom over the OS. You can start a webserver, tune the processes that are started at startup, if you have some linux administration skills, you'll be right at home. With Android, this is another story, as a user you have much less flexibility. The OS is made for phones/tablet thus it is quite hard for apps to manipulate the system. On a phone, you don't want third party app to touch the system. When a developer builds its own system, she wants to tune it exactly to fit her need.

Of course this is more dangerous but an IoT device does not have an app store. The code is loaded into it and then it should run forever (and get updates if it is connected to a network).

Bare metal

Now of course, all this only applies if:

  1. The device does not need connectivity to the outside world,
  2. The device does not need a full blown OS. Linux (or any non-specialized OS) brings a huge overhead: you need a more expensive and more power hungry processor and it's harder to put the electronics in deep sleep mode. If realtime processing is a requirement, an OS might not be the best choice neither.
  3. The device is life critical. That the software runs on top of a huge pile of software layers that the developer does not control. In life critical systems you need strong guarantees that the system handles failure.

In those situations a lightweight approach might be better. Something bare metal without an OS at all or with a specialized embedded one (e.g., FreeRTOS) will be more power efficient and cheaper to produce.

Conclusions

  • Android Things is trying to solve the same problem than Ubuntu Core (or other similar effort)
  • The first question when developing a product is whether or not you need full blown OS. Considering the following criteria:
    • Cost
    • Network connectivity (and thus security)
    • Updates (both the application code and the underlying system)
    • Realtime constraints
    • Lifetime

We will see in the following months which hardware partners Google will have and which guarantees they will give with the update mechanism.

To me, Android Thing would be the killer OS if it was more moldable. There is not a lot of documentation on how to tune the system for a specific need. I guess this will come with time and experience.

Exciting times.

December 28, 2016

Marten Feldtmann - PUM 3 – directions to go

PUM 2 is more or less working, now considerations are done, how to improve and actually we are doing a little step back again.

PUM 2 started with Swagger-Support, but we never actually used it after that initial support. With Swagger 2.0 the Swagger-support (in PUM 2) did not work any more.

But now after swagger emerged to openapis.org (based on swagger), we will try to fix the problems and make it work again. That will lead to some changes:

  • DateTime exchange is now based on RFC3339 again and not Javascript ticks. We thought, that JS Ticks might be a good candidate as an exchange format but actually porting to other languages were now more difficult
  • Remove the Cookie-Support from the server/client runtime. This is a critical/breaking change, but removing cookie support will make it much easier to support other client languages/libraries. But this also means, that session information has to be given to each call by the client …

Java support is wanted by one of our customers and therefore we assume, that a Java codegenerator has to be done in 2017.

PUM in its current state is a Gemstone/S oriented tool and we will go further this direction, as long as we can create/get projects with Gemstone.


Filed under: Smalltalk Tagged: Gemstone/S, PUM

Pharo Weekly - Tarantalk

Hi all,

I’ve developed a new database connectivity library for Pharo, called Tarantalk.
https://github.com/mumez/Tarantalk

Tarantalk is a connector for Tarantool.
https://tarantool.org/

Tarantool is a Lua engine with tuple persistence. It is like a GemStone in Lua.

Firstly, Tarantalk can be used as a tuple-centric DBMS. You can store
arbitrary Smalltalk objects as tuples, and retrieve them by multiple
indexes.

tarantalk := TrTarantalk connect: ‘taran:talk@localhost:3301’.
space := tarantalk ensureSpaceNamed: ‘bookmarks’.
primaryIndex := space ensurePrimaryIndexSetting: [ :options | options
tree; partsTypes: #(#string)].
space insert: #(‘Tarantool’ ‘https://tarantool.org’ ‘Tarantool main site’).
space insert: #(‘Pharo’ ‘http://pharo.org’ ‘Pharo main site’).
primaryIndex selectHaving: #(‘Pharo’).
” => #(#(‘Pharo’ ‘http://pharo.org’ ‘Pharo main site’))”

What is more interesting is that Tarantalk can call remote Lua
functions and can evaluate Lua expressions.
So you can extend your database system freely with Lua and Smalltalk!

— Lua
function bookmarkUrls()
local urls = {}
for k,v in box.space.bookmarks:pairs() do
table.insert(urls, v[2])
end
return urls
end
box.schema.func.create(‘bookmarkUrls’)

“Smalltalk”
tarantalk call: ‘bookmarkUrls’.
” => #(#(‘http://pharo.org’ ‘https://tarantool.org’))”

(tarantalk evalWithReturn: ‘(require(“digest”).sha512_hex(…))’
arguments: {‘Hello, Smalltalk’}) value.
” => #(‘ec599e128831b282f6f7a833834c90a3eb2e61453e5757ca3c2bc8a26e94d7c2f76bd6a7ce33df2427f3821e44a12d26781d39eac6782b59a649950ea59f9e13’)”

Moreover, Tarantalk is pretty fast compared to some other NoSQL databases.
https://github.com/mumez/Tarantalk#performance

A simple micro benchmark shows that Tarantalk is about 5x faster than
RediStick Redis client.

Enjoy!

[:masashi | ^umezawa]


Torsten Bergmann - Pharo happiness

Use Pharo and cognitive services from Microsoft to find out about the happiness of people on pictures. The article is in japanese - but the code example shows what to do.

December 27, 2016

Pharo Weekly - Calypso

Hi

I am glad announce first initial version of new system browser called Calypso.
It is implemented from scratch with idea to build model suitable for remote scenario.
But as result it leads to more important goal: provide clean implementation of browser which people could understand and evolve.

Calypso supports most features from Nautilus but also miss many of them. And there are many not nicely looking parts of UI which require more work.
But in same time Calypso provides many new cool features with clean implementation underhood. I put many things from other smalltalks and old browsers which I always miss.

I release Calypso in the state where I finish most design decisions which I think important for project evolution.
Of course there are a lot of things to do and improve. But browser is fully working. And now it is important to community to participate in project and make browser great again :). We need escape from Nautilus pasta world.
Please report any ideas/bugs on github page https://github.com/dionisiydk/Calypso/issues. I already fill it with my wishes.

Next step I will work on documentation/class comments and I will publish couple of posts about Calypso internals.

Read more details on my blog. It includes pictures, videos and loading script.

Best regards,
Denis


December 26, 2016

Joachim Tuchel - Glorp/DB2 – Tip: Sorting case insensitive

If you are working with Glorp and DB2 and use #orderBy: you may have found out that the results of ordering by CHAR or VARCHAR columns may end up strange. DB2 assumes that a Small letter is less than a capitalized one. “Hans” is lower than “HANK”. In my case this came obvious in a… Continue reading Glorp/DB2 – Tip: Sorting case insensitive

December 22, 2016

Pharo Weekly - Another batch of enhancements

60334
19479 Typo in name attribute of GRVariableAssignedLiteralRule
https://pharo.fogbugz.com/f/cases/19479

19478 Criticsbrowser shows a refactoring class name instead of the text diff
https://pharo.fogbugz.com/f/cases/19478

19438 Widen tolerance for DelayScheduler timing tests
https://pharo.fogbugz.com/f/cases/19438

60333
19484 BaselineOfMorphic references unexisting class
https://pharo.fogbugz.com/f/cases/19484

19483 Add bootstrap specific code in Monticello
https://pharo.fogbugz.com/f/cases/19483
60332
19480 Update Glamour to version 4.27
https://pharo.fogbugz.com/f/cases/19480
60330
18735 DNU on suggestions shortcut in GTDebugger
https://pharo.fogbugz.com/f/cases/18735

19432 Promote DelaySpinScheduler from experimental status (part 2)
https://pharo.fogbugz.com/f/cases/19432

19438 Widen tolerance for DelayScheduler timing tests
https://pharo.fogbugz.com/f/cases/19438
60329
19476 LabelModel default color needs to be theme text color (not hardcoded black)
https://pharo.fogbugz.com/f/cases/19476

19473 empty package Spec-SelectEntity can be unloaded
https://pharo.fogbugz.com/f/cases/19473

19453 NeoUUIDGenerator>>testTwoSameGenerator – intermittent CI failure
https://pharo.fogbugz.com/f/cases/19453

19471 classAffected method for MethodAnnouncement to be polymorphic with other system changes
https://pharo.fogbugz.com/f/cases/19471
60328
19472 QA v3.2.10
https://pharo.fogbugz.com/f/cases/19472

19433 Display critiques in Nautilus inline
https://pharo.fogbugz.com/f/cases/19433

60327
19467 Metalinks: support accessing variables for arguments
https://pharo.fogbugz.com/f/cases/19467

19430 Promote DelaySpinScheduler from experimental status (part 1)
https://pharo.fogbugz.com/f/cases/19430

60326
19341 New class and method tags API
https://pharo.fogbugz.com/f/cases/19341

60325
19464 Clean up Spec-PolyWidgets and Spec-SelectEntity
https://pharo.fogbugz.com/f/cases/19464

19462 Remove all classes of BuildUIWithSpec and BuildUIWithSpec-Reuse
https://pharo.fogbugz.com/f/cases/19462

19460 Make requestor Scope pluggable
https://pharo.fogbugz.com/f/cases/19460

60324
19445 Pattern code ArrayNode matching failure
https://pharo.fogbugz.com/f/cases/19445

18935 Rubric warning are not DarkTheme friendly
https://pharo.fogbugz.com/f/cases/18935

19455 Testcase for reify receiver for before links
https://pharo.fogbugz.com/f/cases/19455
60323
19449 QA v3.2.9 update
https://pharo.fogbugz.com/f/cases/19449

19440 No users of TotalCost and subclasses
https://pharo.fogbugz.com/f/cases/19440

60322
19447 VersionBrowser always shows single method
https://pharo.fogbugz.com/f/cases/19447

60321
19437 Do not log shadowed variables to transcript by default
https://pharo.fogbugz.com/f/cases/19437

19450 Suggestion menu not working on MessageBrowser
https://pharo.fogbugz.com/f/cases/19450

19441 Better description for MessageNotUnderstood
https://pharo.fogbugz.com/f/cases/19441
60320
19442 PharoDocComment
https://pharo.fogbugz.com/f/cases/19442

19443 ProtocolAnalyser
https://pharo.fogbugz.com/f/cases/19443
60319
19412 SpecDebugger cannot work without Glamour
https://pharo.fogbugz.com/f/cases/19412

19428 Silently ignore loading DelayScheduler setting when its the same as existing
https://pharo.fogbugz.com/f/cases/19428

19426 TabsManagerMorph improvements
https://pharo.fogbugz.com/f/cases/19426
60318
19425 Stack underflow with meta links on message nodes
https://pharo.fogbugz.com/f/cases/19425

19284 MetaLink: re-enabling a condition with arguments can not be executed anymore
https://pharo.fogbugz.com/f/cases/19284

18994 Komitter should stringify the commit message (breaks GitFileTree)
https://pharo.fogbugz.com/f/cases/18994

19421 Failing test: WeakAnnouncerTest>>#testNoDeadWeakSubscriptions
https://pharo.fogbugz.com/f/cases/19421

19415 classVariableAdd and classVariableRemove not announce ClassModificationApplied event
https://pharo.fogbugz.com/f/cases/19415

60317
19409 ClassTagRemoved is not announced when packageTag is removed when it becomes empty after class is moved
https://pharo.fogbugz.com/f/cases/19409

19319 Editing methods in filtered MessageBrowser raise error
https://pharo.fogbugz.com/f/cases/19319

19417 Loading new trait methods put them into unclassified category of user classes
https://pharo.fogbugz.com/f/cases/19417

60316
19418 Spec TextModel editor has broken cancel operation after first accept
https://pharo.fogbugz.com/f/cases/19418

19413 GTInspector/Debugger do not work for large/ toolarge intervals
https://pharo.fogbugz.com/f/cases/19413

19420 redu menu item is wrong and not working for rubric
https://pharo.fogbugz.com/f/cases/19420


Marten Feldtmann - Dolphin 7 with Jade IDE under Wine/Ubuntu 16.04

As I mentioned earlier on the site I managed to install Dolphin 7 under Ubuntu 16.04 – but I had to install a much, much newer version of Wine and you get the latest version directly from the developer site of Wine.

Then you have Dolphin 7 available on your desktop and its time to try out the Jade IDE to import it into a running Dolphin7 image. James describes how to build a IDE from Github – but for that you need all development tools and one does not have that under Wine.

So we save our image and the core problem in the whole work is to find out, where the files are located.

Normally all stuff is located below the “.wine” folder in your home directory – but the documents directory of the wine current user (same name as your Ubuntu user) points to the normal Ubuntu “documents” (German: “Dokumente”) folder. Looking into this folder you might see a “Dolphin Smalltalk 7” folder.

Be sure to install the 7.0.32 version published several days ago from ObjectArts

Going into that directory you may find the Smalltalk image you just saved …

Now execute in that directory:

git clone https://github.com/jgfoster/Jade Jade

and all the Jade stuff is available. It turns out, that you just have to file in the “BootJade.st” file located in the “Jade” directory. That should it be.

But I do not know why – the loading failed. Can not find all the files …

I changed the “BootJade.st” file content to:

PackageManager current install: File workingDirectory, ‘\sources\’ , name , ‘.pax’.

and you can load all the stuff – bingo.

Under “Additional Tools” you may find the Jade Login GUI, start it and try to login.

Fails: reason seems to be, that all the low level libraries are not found.

Hmmm. It seems, that the working directory is not correctly set. I had to move all stuff within the Jade directory one level higher … and now you can connect.

 

 

 


Filed under: Smalltalk Tagged: Dolphin, Gemstone/S, Jade IDE, Ubuntu 16.04, Wine 2.0

December 21, 2016

Marten Feldtmann - Gemstone/S application example

Here is another example for an application developed with the toolchain we developed over the time. It’s a CATI software system – get interviews by calling persons for different purposes.

The system is similiar to the election system I mentioned in spring this year on this site. The base component for this system is the oo-database Gemstone/S. Several external applications are communicating with the database via a HTTP-RPC API programming style.

The whole stuff is modelled with PUM, the API is defined via PUM and code is generated for the following actually used programming languages: for Topaz (Gemstone/S), Sencha ExtJS (Javascript) and Python 3.5.2. The domain model itself is about 1/3 larger (in terms of source code) than the election system mentioned in earlier postings.

The application itselfs is also pretty much different – its much more multitasking. Lots of concurrent users may connect to the database, background jobs are executing and so on.

The communication between clients and database is normally done via browser-based applications (written in Sencha ExtJS) and the database via HTTP. The database itself is not a frontend http-server, but all components are tunneled through the original HTTP-server: an Apache/2.

The requests are handled by several Topaz processes, with different memory contraints – all API calls are defined according to the “believed” memory consumption during requests execution. Load-Balancing is done by Apache/2 and it leads the requests to the Topaz process with the correct memory configuration.

The much more interesting part is the introduction of ZeroMQ. The database now sends “events” (indicating some domain events like login, logout, interview ended, ..) over a “publish-subscribe” socket pattern to external applications. Most of these service programs are written in Python 3.5.2.

But also the browser based application need some events and we wrote a Python based ZeroMQ <-> WebSocket relay. The relay is also tunneled through the Apache/2 server.

Now the browser application – when doing active work – may communicate with the database with HTTP, but are also awaiting informations via incoming events received via a WebSocket connection. In future we may only use WebSockets for all kind of application – we will see.

Some additional tools are written in Python scripts: interfaces to dialer systems, to time-management systems – and simulated interviewers🙂

These simulated interviewer programs are the most interesting things – they show the concurrency problems within the whole structure. They also show, that 400 interviewers working against this application server are not a load problem. The problem will be the 1-5 supervisors doing lots of statistic data and to visualize the current state of a CATI studio. These few users produce much more CPU work !

The high concurrency of this system also pops up another interesting fact: simple jobs become difficult: transfering 100000 domain objects from one queue to another queue become now a candidate for conflicts. Such jobs have to be rewritten in a adapting way, so that the jobs can be done in multiple smaller jobs etc.

The longer the API calls needs, the more is the risc of conflicts and transactions are aborted.

And of course we also build fat clients from our www-clients by using the Election technology. They are working – but we still have to think about, how to improve such a fat client in contrast to a pure web-client.

Drawbacks found ? Well yes: a more structured query language would be nice.

 

 

 


Filed under: Smalltalk Tagged: CATI, Electron, ExtJS, Gemstone/S, PUM, Sencha, Smalltalk, VA Smalltalk, WebStorm

The Weekly Squeak - Eliot Miranda – Lubrication and Flow

Eliot gave a terrific presentation about the current state of the community and what we might do to improve it.

Evelyn (Lin) Ostrom

1933-2012

Eight principles for managing a commons

  1. Clearly defined boundaries
  2. Proportional equivalence between benefits and costs
  3. Collective choice arrangements
  4. Monitoring
  5. Graduated sanctions
  6. Fast and fair conflict resolutions
  7. Local autonomy
  8. Polycentric governance

http://www.onthecommons.org/magazine/commons-strategies

http://fast.org.ar/talks/lubrication-and-flow

Editorial: by Ron Teitelbaum follows

Eliot gave the presentation to help get the discussion going (it’s not the start of the conversation either, there are earlier efforts like the Pharo Consortium) this Article is part of that discussion.

My take on the conversation is that there are really two aspects of what Eliot is discussing.

First that some sort of economic organization that helps Smalltalk is needed and that the organization should be used to help both programmers and customers.  It seems to me that a Smalltalk Guild could be set up to do just that.  It would be a place for customers to find certified developers with access to a group of people (other guild members) that can solve difficult problems if they get stuck.  It could also be a place where members who make over a certain amount of money could get proportional benefits.  As a developer. I would probably join such a guild and as a customer, I would love to have a place to go which could help me solve some programming issues.

Second that we need to have better visibility, coordination, and cooperation.  The cost of coordination using technology is falling fast.  Having a site that pairs tasks with developers, shows developers guild certifications, allows for customer and developer ratings and comments, highlights training materials and growth paths, and generally allows communities to form and disband around specific areas funded by companies or the guild itself would fundamentally change how we organize and grow the community.

To illustrate let’s say we form a Smalltalk Guild.  Members pay $10 a year to join + %10 of what they make on jobs they get through the Guild Jobs.  Companies can also join the guild and pay $100 per year and pay %10 in addition to what they pay for a job if they hire a Guild member to do the work.  (These are just made up figures I have no idea if they would actually work and some study would be needed to figure that out).  As a group, the Guild can provide Training for new members, create certification levels and growth plans.  The incentive for the group is that as members grow and make more money everyone benefits, there is an incentive to make sure people are qualified, can do the work, and actually get work instead of doing nothing (like java programming).  Users that contribute over 10k to the guild (earn 90K) can get benefits if they are out of work, or maybe healthcare on a group plan, some form of compensation which of course would be less than they contribute + generate in customer fees and would be decided by the Guild as Eliot says 0.N/X.  This gives the best guild members an incentive to stay with the guild and to feel like the guild is helping them provide some basic needs and it allows the guild to acknowledge the contributions the member is putting in to help the entire group.  The money could also be used to benefit the Guild.  To pay for someone’s training or certification, to increase visibility, to look for donors, find new customers, invest in new training materials, new conferences, courses, or even develop technology like the VM or application frameworks based on the group’s collective choices.