smalltalk | Promise-based Alert , Confirm and Prompt replacement | Reactive Programming library

If you want to search in the text output when sending messages, I would simply redirect the output to file.

I would do the following:

1. gst -a > netclients_namespace.txt
2. type: NetClients examine
3. check the netclients_nemespace.txt file where you will have the output of the messages. You can check it while the gst is still running
4. If you are done just break it via ctrl+c

Explaining:

I presume that the assignment consists in adding categories programmatically. In that case, this is how you could learn how to add a category.

1. Find the class you want to add the category to
2. Inspect the class and take a look to its instvars
3. The categories of the class should be there somehow
4. The ivar whose name looks promising is organization
5. Its class is ClassOrganizer
6. Check to see whether there is a ClassOrganizerTest for testing it
7. Found! Take a look at the tests and see if you can find what you are looking for.

I believe that this is a bug in GNU Smalltalk. It appears that the system allows you to reference variables that have not been defined (this "feature" is not standard) and the system's attempt to define the variables and their scope is having problems.

The work-around is to define your own variables and give them as narrow a scope as possible (this is good practice in any language). So, try the following (validated at here):

As Leandro Caniglia mentions in the comments of the post, the problem is that currentRow is a String, while I was expecting it to be a collection, and therefore, in the columnsCollection loop, I'm accessing a single character instead of an element from the collection.

The solution was to change how I'm reading in the rows to make sure they are taken as a collection of collections instead of a collection of Strings.

AFAIK private attributes aren't as emphasized in Python as other languages. Every attribute is easily accessed, so dedicated getters/setters that get around "private" attributes is mostly honor system. So this would be the go-to:

You can use

Your tidyverse solution seems pretty good. For something more concise you could try base R or data.table:

As Beck explains, some clients may need to enumerate a collection in a way that the elements are sorted before exposing them, others would require not iterating twice over the same object (which may appear twice in the collection), etc.

One way to address these situations would be to add methods such as #sortedDo:, #withoutDuplicatesDo:, etc. to the collection class. Sooner or later, this approach would derive in populating the class with other variants of #do: such as #sortedSelect:, #withoutDuplicatesCollect:, and the like. The problem is that the resulting protocol of the class would quickly grow too large, adding complexity to the simple task of finding the right selector, increasing the risk of duplicating pieces of code when the search is not exhaustive enough, etc.

To avoid those side effects, the class should provide methods for converting its instances in instances of other classes. So, instead of #sortedDo: the client may use

As the compiler tells you, you cannot move a value out of a place observable by others. But since you have the replacement at the ready, you can use std::mem::replace: