Newer posts are loading.
You are at the newest post.
Click here to check if anything new just came in.

March 29 2017

Christian Schudt: Future - About the New Asynchronous API in Babbler

This is a topic which is long overdue, but still pretty interesting: The new asynchronous, non-blocking API for IQ requests in Babbler (since version 0.7).

The Problem

Until the previous release, all IQ-based API was synchronous and did block until the IQ response has been received.

Lets have a look at what that means and how Last Activity (XEP-0012) of an entity was retrieved to illustrate the problem:

LastActivityManager lastActivityManager = xmppSession.getManager(LastActivityManager.class);
LastActivity lastActivity = lastActivityManager.getLastActivity(Jid.of(""));

The method getLastActivity() sends out the IQ request and then waited (blocked) a few milliseconds or even seconds for the response or until a timeout happened.

Having blocking operations is of course resource consuming because you have to dedicate a thread for it, which however is blocking most of the time while waiting on the operation to finish. It's the same issue as with blocking IO and the reason why NIO exists.

Doing multiple blocking IQ queries in parallel means, you have to create a thread for each query.

If you want to do such an IQ query from a JavaFX application you also had to write a lot of boilerplate code like this:

Task<LastActivity> task = new Task<LastActivity>() {
protected LastActivity call() throws Exception {
LastActivityManager lastActivityManager = xmppSession.getManager(LastActivityManager.class);
return lastActivityManager.getLastActivity(Jid.of(""));
task.stateProperty().addListener((observableValue, state, state1) -> {
switch (state1) {
case FAILED:
new Thread(task).start();

You don't want to block the UI thread and therefore need to run blocking operations in a background task.

Furthermore the blocking API in Babbler was not interruptible because it didn't throw InterruptedException. Of course we could have solved the interruptible issue easily, but you still would have the drawbacks of a blocking API.

Futures to the Rescue

Instead of waiting for the response and then returning the result, all IQ-based APIs now return a java.util.concurrent.Future:

Future<LastActivity> lastActivityFuture = lastActivityManager.getLastActivity(Jid.of(""));

The method call is now asynchronous, it no longer blocks and passes control immediately back to the caller!

As with every Future, you can get the result with its get() method:

LastActivity lastActivity = lastActivityManager.getLastActivity(jid).get();

or with a timeout:

LastActivity lastActivity = lastActivityManager.getLastActivity(jid).get(5, TimeUnit.SECONDS);

You might ask, what we've gained now, because the get() method is blocking again and usually you need the IQ result anyway.

Well, that's true. One part of the answer is that we gain interruptibility and the other part is that the returned result is not only a Future, but also a java.util.concurrent.CompletionStage (Java 8's new toy).

CompletionStage<LastActivity> lastActivityFuture = lastActivityManager.getLastActivity(Jid.of(""));

It basically allows you to react asynchronously when the result is present, i.e. when the Future is done. Some frameworks like Guava already have such a concept of a "Listenable Future", now it's part of the JDK.

Taking our JavaFX example from above, updating the UI with the result as in the above example can now become a simple one-liner:

lastActivityManager.getLastActivity(jid).thenAcceptAsync(this::updateUI, Platform::runLater);

It sends the IQ request and later when the response is received it asynchronously executes the updateUI method in the JavaFX thread.

No more blocking, no more extra threads, everything is asynchronous!

Even better:

CompletionStages can be chained together. There are use cases, which require multiple IQ queries like Service Discovery or File Transfer. They can then be composed together into one:

CompletionStage<Boolean> isSupported = xmppClient.isSupported(LastActivity.NAMESPACE, jid);
CompletionStage<LastActivity> lastActivityFuture = isSupported.thenCompose(result -> {
if (result) {
return lastActivityManager.getLastActivity(jid);
} else {
throw new RuntimeException("XEP-0012 not supported by" + jid);

This code first checks if Last Activity is supported (using Service Discovery) and only if it is, queries the entity.

File Transfer is pretty complicated, with a lot of queries going on. This pseudo-code example illustrates the power of composing asynchronous calls (IBB fallback not shown here):

CompletionStage<ByteStreamSession> future =
initiateStream() // Initiate a file transfer stream with somebody
.thenCompose(streamInitiation -> discoverStreamHosts() // When accepted, discover SOCKS5 stream hosts
.thenCompose(streamHosts -> letReceiverChoseOne() // Query the receiver and let him choose a stream host
.thenCompose(streamHostUsed -> activateStreamHost() // When receiver responds with the chosen stream host, activate it
.thenApply(result -> createByteStreamSession())))); // After activation, create a stream session.

For convenience there's also a class AsyncResult, which implements both interfaces.

I think asynchronous programming is the future :-) and this is a first, but huge step in the right direction.

March 28 2017

Erlang Solutions: How Would the World Embrace Video Collaboration if it Couldn’t Scale?

<h3>“How would the world embrace video collaboration if it couldn’t scale?”</h3> <p>This is a big question that Vidyo spotted early on, way back in 2005, as it set out to pioneer the next generation of video conferencing. </p> <p>Video collaboration at that time was primarily used for communicating between one traditional conference room to another. Since then, the world has changed. Today, in a time when “the office” can increasingly mean “pretty much anywhere” for millions of workers, (and consumer-facing apps are turning to video to service millions of customers), building a scalable video platform presents a new set of requirements. </p> <p>We are happy to share what we’ve learned over the years with developers who are interested in the next wave of video communications. At 1 PM EST on 3/29, <a href="">join us</a> for our <strong><a href="">“Building a Global Video Chat Platform for Developers”</a></strong> webinar, as we discuss the challenges faced and solved when building a developer platform that delivers real-time, mobile, multiparty video. </p> <h1>Today’s video collaboration landscape</h1> <p>Today, clear and reliable video collaboration has lept out of the conference room and into our pockets, letting us hop on a video call from our smartphone or tablet while on the train, in the airport or on the road - with more or less the same audio/visual quality as a dedicated room system that enjoys a perfect ethernet connection and high bandwidth. </p> <p>When hundreds of people can reliably connect face-to-face at the same time, from wherever they happen to be, this method of communicating is proving to be transformative for critical fields like healthcare, banking, government and education. This is especially true as we work to make nuisances like dropped calls, lag, grainy or blurry visuals and frozen screens a thing of the past - and stunning levels of clarity and consistency become more of the norm, from basically anywhere. </p> <h1>Behind the scenes</h1> <p>Vidyo has diligently developed patented <a href=";utm_campaign=erlang&amp;utm_medium=webinar">adaptive video layering</a> and routing technologies that have ultimately given us a reputation as the go-to enterprise-grade video service, especially among industries with tight regulations and high security demands. </p> <p>For years, global enterprises have video-enabled their applications using our APIs and SDK. Now, however, the video conferencing market is shifting to embedded video - with the vision that developers should be able to easily video-enable any application on virtually any device - effectively “video-enabling the world”. When we decided to make the shift to embedded video and roll out our video API platform, <strong><a href=";utm_campaign=erlang&amp;utm_medium=webinar"></a></strong>, we knew that our customers would continue to demand Vidyo’s specific brand of mobile, multiparty video that is highly scalable, without sacrificing its quality. </p> <h1>Spoiler: it’s not all plain sailing</h1> <p>One of the challenges today of offering high-quality video collaboration at scale, is signaling. Initially, we built our own signaling protocol. We had a very scalable platform that was ideal for our enterprise customers, which could easily scale to tens of thousands of users. </p> <p>But, with, we were building a global video API platform to be used to video-enable any concept or idea that application developers could think of, whether for enterprise business or consumer-facing applications. We chose MongooseIM because we needed signaling that could scale to millions of users. </p> <h1>Why MongooseIM was the solution for us</h1> <p>We found MongooseIM to be simple, flexible and reliable, and designed for this type of global Internet scale. XMPP is the battle-hardened standard, with the interoperability and classical benefits (like chat, historical chat, etc.) that we, as a uniquely enterprise-grade service, needed for an architecture that could get to 99.999% uptime.</p> <p>This is how video collaboration has lept out of the conference room and into the pockets of millions of people around the world. </p> <p>As we brought <strong><a href=";utm_campaign=erlang&amp;utm_medium=webinar"></a></strong>, to market, our priorities included geo-scalable distribution, easily working through firewalls and accounting for compiled code along with native code and browser access (as WebRTC is becoming increasingly important to the video space). At the time, we evaluated all XMPP platforms. We found that Erlang was the best solution for us, and it has gone on to help us significantly on our mission to offer embedded video to the world that “just works.”</p> <h1>Ask me anything</h1> <p>I’m proud to say that today, has been featured on, ProgrammableWeb, App Developer Magazine, Software Development Times and elsewhere. Video is now becoming ingrained in everything people do. </p> <p>I’ll be speaking more in depth on the ups and downs of building a real-time, multiparty video platform with Erlang Solutions. <strong><a href="">Register for the webinar</a></strong> if you are interested in learning more about my experience, the technology, and to take part in the Q&amp;A panel afterwards. You can ask me anything!</p> <p>Learn more about <strong><a href="">MongooseIM</a></strong>, Erlang Solutions’ high volume messaging solution. </p>

March 26 2017

Peter Saint-Andre: Unethical Philosophers

Reports and allegations continue to surface regarding widespread sexual misconduct by male philosophy professors, including "stars" such as John Searle and Thomas Pogge (as well as several professors here in Colorado). The sad irony and arrogant hypocrisy of professors of philosophy engaging in such despicable and deeply unethical behavior cannot be passed by in silence. We witness here in a particularly painful form the truth of Thoreau's observation that "There are nowadays professors of philosophy, but not philosophers." According to Thoreau and the ancients, "to be a philosopher is not merely to have subtle thoughts, nor even to found a school, but so to love wisdom as to live according to its dictates" - which these piddling professors clearly fail to do....

March 24 2017

ProcessOne: ejabberd 17.03

New modular code, flexible core backend, dynamic configuration reload, spam protection and routing API changes.
These are the most interesting improvements coming in 17.03.

As usual, we also included several other improvements and many bug-fixes. In summary, almost 3K new lines of code and other 10K changed lines.

Many thanks to all of you which tested and sent feedback over the beta testing period!


Modular code

New modular code allows to develop modules for a wide scope of functionalities without patching the core code such as C2S, S2S and router.

Routing API

Now ‘From’ and ‘To’ arguments must be omitted in functions and structures related to routing.
The commit deprecates the following functions:

  • ejabberd_router:route/3 in favor of ejabberd_router:route/1
  • ejabberd_router:route_error/4 in favor of ejabberd_router:route_error/2
  • ejabberd_local:route_iq/4 in favor of ejabberd_local:route_iq/2
  • ejabberd_local:route_iq/5 in favor of ejabberd_local:route_iq/3

The format of {route, From, To, Packet} is changed in favor of {route, Packet}.
API changes will be better described with 17.03 release when new API documentation will be completed.

Flexible core backend

Ejabberd used to store all in-memory shared data such as ACLs, proxy65, sessions, routes, clustering, etc in internal Mnesia database and this used to be hardcoded. With new API it’s now possible to store such data in any database.
However, currently only Mnesia backend is supported, but we’re working on implementing other backends (redis, sql) in future releases.
For the record, it’s already possible to store client sessions in Redis and/or SQL servers, the API was just extended to make it possible to implement such a backend for any in-memory shared data.

New features

Dynamic configuration reload

Using ‘reload_config’ ejabberd’s command it is now possible to reload modules, database connections, listeners, ACLs and global options without restarting ejabberd.
Thanks to this improvement, it’s now possible to add and remove virtual hosts via configuration reload.

Spam protection

If you want to get ride of XMPP SPAM, best option is now to use our new feature implemented by mod_block_strangers. This module just allow to block packets from non-subscribers, this means you won’t receive messages from users not registered in your roster.

S2S dialback

S2S dialback is now an optional module. If not present in the configuration, only TLS mechanism can be used to establish S2S connections.


While upgrading an existing system, you need to care about few required changes. In order to enable S2S dialback, stream management (XEP-0178), legacy client auth or the new anti-spam feature, the following modules should be added to ejabberd’s configuration:

  • mod_s2s_dialback
  • mod_stream_mgmt
  • mod_legacy_auth
  • mod_block_strangers

If you have issues using PubSub with Postgres backend, please check the full schema update from sources.
While in runtime, you can run the following bare minimal changes to fix PubSub

ALTER TABLE pubsub_state ALTER COLUMN subscriptions SET DEFAULT '';
UPDATE pubsub_state SET subscriptions='' WHERE subscriptions=null;


Here are the most relevant changes


  • tools/ checks hook dependencies
  • tools/ checks which dependences need update
  • Mark as deprecated add/get_local/global_option config functions
  • Change routing API


  • Fix some corner cases while re-reading RFC6120
  • Attach IP metadata to every stanza received from stream
  • Apply SASLprep before storing/converting passwords
  • Send compressed in correct order
  • Reset XML stream before sending SASL success
  • Speedup features list when a lot of virtual hosts configured
  • Fix s2s_dns_timeout issues
  • Better handling of IPv6 domains
  • Rename mod_sm -> mod_stream_mgmt
  • Don’t count resent stanzas
  • Improve startup procedure, and log startup time
  • Add more processes to supervision
  • sm_sql: Avoid PID collisions


  • Add ‘supervisor’ listening option
  • Accept “add_commands: admin” in commands section
  • Make sure that api_permissions always have “console commands” section
  • Change name of pam dep from p1_pam to epam
  • Improve compilation with rebar3
  • Add TLS support for external components
  • Specify “ExecReload” command in systemd unit
  • Don’t attempt to resolve _jabber._tcp SRV record
  • Improve error reporting for forbidden servers
  • mod_block_strangers: New module to block packets from non-subscribers
  • mod_register: Report password change in the log
  • Remove relict mod_service_log
  • Remove unused mod_ip_blacklist
  • Remove ejabberd_frontend_socket
  • WebAdmin: improve formatting when showing erlang terms
  • Import from Prosody: Fix import of SCRAM passwords, offline

API & Commands

  • get_last now always returns tuple with UTC XEP-0082 and status
  • Protect users from delete_old_users command using a fixed access rule
  • Separate list of strings with \n for srg_get_info in mod_http_api
  • Support non-JID lines in command create_rooms_file
  • stop_all_connections now stops all s2s connections via supervisor calls
  • Support scrammed passwords in ejabberdctl import_prosody


  • Provide example mod_http_api configuration with couple commands
  • Clarify new modules usage in the example config
  • Don’t crash on malformed IP addresses
  • Fix parsing of acl/access rules inside oauth sections of api_permissions

Config reload improvements

  • Start/stop auth modules when host is added/deleted
  • Improve modules start/stop procedures
  • Check result of gen_mod:start/2 callback
  • Improve reload_config admin command
  • Invalidate access permissions on configuration reload
  • Start/stop virtual hosts when reloading configuration file
  • Reload modules when reloading configuration file
  • Restart listeners on configuration reload
  • Make sure all hooks are called with proper host


  • Add missing NOT NULL restrictions in schemas
  • Move archive tables into lite.sql for better comparison with other schemas
  • Implement database backend interface for mod_proxy65
  • Implement database backend interface for MUC, BOSH and auth_anonyous
  • Implement database backend interface for ejabberd_router
  • Propagate the TRANSACTION_TIMEOUT to pgsql driver

New XMPP stream behavior

  • Reflect cyrsasl API changes in remaining code
  • Improve return values in cyrsasl API
  • More refactoring on session management
  • Add xmpp_stream_out behavior and rewrite s2s/SM code
  • Rewrite ejabberd_service to use new XMPP stream API

MAM & offline storage

  • Make a message is not bounced if it’s archived
  • Archive message before delivering it to offline storage
  • Include stanza ID with archived offline messages
  • Add stanza-id to every archived message


  • Avoid orphan_item leak on affiliation/subscription removal
  • Fix pubsub SQL schemas, add NOT NULL restrictions
  • Fix last item cache for multiple hosts

Server to server

  • Several improvements of S2S errors logging
  • Resolve all addresses from SRV lookup
  • Add s2s work-around for


As usual, the release is tagged in the Git source code repository on Github.

The source package and binary installers are available at ProcessOne.

If you suspect that you’ve found a bug, please search or fill a bug report on Github.

March 23 2017

The XMPP Standards Foundation: First Paris XMPP meetup

After Berlin, Stockholm, and London, here is Paris. The trend of new XMPP meetups in major cities in Europe is confirmed.

The Paris meetup is simply organised by the JabberFr community, as this will be mostly oriented discussions on modern XMPP/Jabber.

Details are available on JabberFr,, and agendadulibre.

The XMPP Standards Foundation: New XMPP Software Listing Rules

The XSF provides a public list of XMPP implementations on its website. For this list to be useful, it should contain up-to-date information about up-to-date software. To achieve this, the XSF Board has decided that all implementations have to reapply once per year, to ensure that they are still actively maintained and that the listed info is accurate. This is a purely formal process, though we encourage implementors to follow the current compliance suites.

If you have an entry in one of the lists, please create a pull request as desribed in the README before the 1st of May 2017. There is an example commit that can be used as a reference. Software that is not updated until that date will be automatically removed from the listing. Alternatively, you can ask in the jdev MUC for a manual update of your listing.

Please also ensure that you repeat this step in the following years.

March 21 2017

Swift Blog: Swift and Google Summer of Code 2017

It’s Google Summer of Code time again! Swift is participating in GSOC2017 under the banner of the XMPP Standards Foundation and we’ve posted a range of project ideas covering Swift and Swiften on the XSF wiki. Read on for more information.

As reported in a post on the XMPP Standards Foundation blog, the XSF has once again been accepted as one of the Open Source organizations participating in Google Summer of Code.

We’ve listed some "potential ideas for Swift and Swiften GSOC projects on the XMPP Wiki so, if you’re interested in participating as a GSOC student this year, please take a look.

If any of these projects are of interest, or if you have ideas of your own you’d like to propose, then please join the chat room to discuss GSOC and ask questions. We’ve had some great experiences with previous GSOC projects and we’re very much looking forward to working with students this summer.

March 20 2017

Ignite Realtime Blog: Smack 4.2.0 released

Around two years ago, on 2015-03-29 to be precise, Smack 4.1.0 was tagged and released. A few days ago I've tagged and released Smack 4.2.0 to Maven Central. The 4.2.0 release marks a milestone for Smack, but before I got into the exciting new features, I'd like to thank the various contributors:


$ git shortlog -sn 4.1.0..4.2.0

   459  Florian Schmaus

     8  Fernando Ramirez

     3  Anno van Vliet

     3  Tibo-lg

     3  damencho

     3  ramabit

     2  Andrey Starodubtsev

     2  Vyacheslav Blinov

     2  stawny

     1  Andrey Prokopenko

     1  Craig

     1  Daniel Hintze

     1  Dave Cridland

     1  David Black

     1  Dmitry Deshevoy

     1  Grigory Fedorov

     1  Hugues Bruant

     1  Ishan Khanna

     1  TheHaf

     1  Tomas Nosek

     1  Tomáš Havlas

     1  UltimateZero

     1  Vaibhav

     1  meisterfuu

     1  rohanag12

     1  vfite


I can not remember when Smack had so many contributors. Thanks everyone and keep the contributions coming.


The notable changes to Smack 4.2 include support for DNSSEC (thanks to a previous MiniDNS GSOC project), JIDs as first class citizens by using JXMPP's JID API, and tons of other improvements, new features and bug fixes. You can read more in the Smack 4.2 Readme and Upgrade Guide and the Smack's JIRA release notes.


Last but not least, thanks to Bilal Siddiq, Smack now has a logo.


Ever wanted to contribute to open source? Are you interested in XMPP/DNS/DNSSEC? Google gives students the chance to work on open source projects and get paid for it as part of Google's Summer of Code 2017. The XSF acts as umbrella organization for projects like Smack and MiniDNS [4]. Feel free to contact me in the if you are interested in participating or if you want to discuss your own Smack/MiniDNS related project ideas.

March 16 2017

Christian Schudt: Babbler Version 0.7.4 released

Version 0.7.4 of the Java XMPP library has been released to Maven Central!

It turned out there was a rare deadlock, when using Stream Management. It happened only rarely and was hard to spot, but when it did, it was of course a blocker.

Here's the full changelog:
  • Resolve rare deadlock when using Stream Management
  • Rework how WebSocket connections are closed
  • Don’t let a stream error close the stream immediately, but instead wait for the closing stream element and then close the connection.
  • Increase performance of IBB stream
  • Prevent rare, but possible NullPointerException after sending stanzas.
  • Fix error when using pages (XEP-0141) within data forms (XEP-0004)
  • Reset nick to null, if entering a chat room fails

March 14 2017

Jérôme Poisson: Cagou(SàT): development progress of the desktop and Android XMPP frontend

Salut à Vous !

It's been a little more that one year now that the crowdfunding campain has been successfuly completed, and that we have promised to develop a new Desktop/Android frontend for "Salut à Toi", our Multipurpose, multi frontend communication tool based on XMPP.

It's time for an overview of the state of the development. You'll find below a link to the first .apk (pre-alpha), FOR TESTING PURPOSE ONLY.

Cagou (SàT)

As we've already announced, the new Desktop/mobiles (Android only for now) frontend will be named "Cagou", a wind to the Kivy framework that we're using, and to this endemic bird of New Caledonia, which bark and can't fly.

Oh, and yes we know that "Cagou" has different meaning in different languages.


This part is technical, you can go directly to the next one if you're not interested.

After a short time to get familiar with the Kivy ecosystem, the first step has been to integrate "Quick Frontend", which is a common base that we are using, as you guess, to quickly develop a frontend and factorise the code (cache handling, contact list – or "roster" in XMPP world –, widgets, etc.), then to integrate the "bridge" which is the name that we are using for the IPC and which handle the communication between the backend (which is the heart of SàT) and the frontends.

This phase went relatively well, and was followed by a thought on the architecture and user interface.

Once all of this was more or less usable, the Android port could began.

Things have been a big more complicated there. The Kivy community has created several tools to develop on this platform, including python-for-android (compilation and archive creation tool), and Buildozer (multi-platform tool to facilitate the use of the first one). Using these tools take some efforts, specially for a project already well advanced (it's far more easy if you start directly with Kivy and the Android port).

There a 2 "chains" for developing on Android: the old and the new one. After the first unsuccessful tries with the new one, it has been temporarly put aside for the old one, the time to build the foundations of the port.

Pure Python dependencies can be imported easily, but as soon as it get more complicated, you'll have to creates "recipes" to tell how to build something to python-for-android. Fortunately, most of those needed for SàT (Twisted in particular) were already available, and just needed to be updated.

After all this dependencies and building chain problems solved, and after the joy to see the first .apk (no working), 2 other big troubles showed up: D-Bus which is the main "bridge" is not usable on Android, and how to have the backend and the frontend running together?

Being my first Android development, I've had to read a lot or documentation (which luckily is not lacking), and after a first try with a bridge "embedded", allowing to have backend and frontend in the same process, it's finally a new "pb" bridge which solved the issue. "pb" stands for "Perspective Broker", the Twisted IPC. Android native IPC is an other option to be evaluated in the future.

To launch the backend, Kivy comes with modules to start it as an Android service. With it, the backend can stay in background and process messages and other activities when the frontend is not visible to the user (which means frozen until the user show it again on Android).

This section is already long, so I'll skip other problems (like the lack of HTML widget), and let's now talk about the UI.


At the moment Cagou is usable on desktop (GNU/Linux, but other platforms will most certainly follow), and on Android.

The current release is a pre-alpha, the .apk is available below, only to have a rough idea of the software. It is really bugged, doesn't check yet server certificates, doesn't handle SRV record on Android, etc. This is linked for 2 reasons: showing the progress, and having feedbacks early enought to go in the right direction.

You can't create account from the application (this will come before the release), so if you have no account yet you can use Libervia(SàT), the demo instance of our web frontend, to create one.

main concepts

Cagou's UI take inspiration from the excelent Blender. The widget selection and splitting are the most obvious examples. The huge bars that you can see should disappear later in favor of a small button, which may follow Blender example again. The goal here is that a newcomer can switch widgets intuitively, and an advanced user can use this splitting feature.

widgets split

The contacts list is not the central element in the interface, it can be displayed if wanted, but it's not needed to use Cagou.

The upper menu, which is for now always visible, will certainly be only available on Desktop. On Android the menu button or a floating touch one should replace it before the release.

If you have notifications, they should appear for a couple of second on the top, but you can read them later by touching the cagou head on the upper left.

notification in Cagou

If there is an event needing user action (for instance a website needs your authorisation with XMPP), an other cagou will appear on the right, and the dialog will only appear after touching it. The idea is to never have an unwanted popup stealing the focus when you are doing something else: popups are displayed only with explicit user action.

In Android case, it may be replaced by the native notification system in the future, but it's not decided yet because notifications history would not be available anymore.

To change the mode (widget), you just have to click on the upper left button in the current widget. Only 4 widgets are available so far: the selector which display all widgets available, the settings, the contact list, and the chat. Other are planed, notabily the blogging one.

widget/mode selection

Inside a widget (only for chat so far), you can swipe horizontaly to switch between active conversations.

widget swipe in Cagou

For now it's not easy to use the first time (you have to do a very quick swipe), it needs some tuning.

As for other SàT parts, Cagou is thought since the beginning to work with plugins and being easy to extend. All the widgets and file transmitting system (see below) are plugins.

instant messaging (chat)

As we want a frontend usable on small screens, which is simple but without making sacrifice on features, we have to find a compromise between data displayed on the screen and the elements/buttons needed for actions. Too many elements will make the UI more complicated and take room, but not enough will make the actions more difficult to do.

The current design (which can evolve) has a header with an input bar and a button (in addition to widget selection button), the body with messages, and a bottom input bar with a button too.

To talk with one or more contact(s), type some letters belonging to its name (anywhere in the name). For now, only identifiers ("jid") and already opened talks are looked for, but later the search will include names, nicknames and bookmarks.

contact selection for instant messagin

Cagou detect if you want to talk to a single person, or to a group chat room, and will act consequently.

The end 2 end encryption is there, but only with OTR (v2) for the moment. OX (modern OpenPGP) and OMEMO are planed, but it's not sure that they will be available for the next release (they may be there for the following one, 0.8). To use it, you just have to click on the lock, it will be closed if the chat is encrypted, and will have a question mark if your contact is not authenticated.

Let's go directly to the input bar. You'll see on the right a "+" button, click on it and you'll have a sending dialog.

This dialog has 2 buttons on the top, with which you can choose between uploading the file or sending it directly using peer 2 peer. A text under them explain in simple language where your file will go, and if encryption is done (for now all files are sent unencrypted).

This text message is important to let the user understand where the data are transiting, it's the kind of information we plan to put in several locations.

file sending dialog on Android

The buttons below are the various transmitting options. On desktop, you can only use a file browser (for now), but on Android you can also send a picture from your gallery, take a new photo or a video, or record a voice message.

He is a screenshot of voice recording:

recording a voice message

around Cagou

In addition to the work on Cagou itself, other things have been done.

A now mandatory feature with the explosion of mobile devices, carbon copy has been implemented. Server archives is implemented for long fot blogging, but not yet for chat messages, it will be done before the stable release.

Small binary files handling ("BoB" for "Bits of Binary") is now available. Implentation has been motivated by its use on the friend project Movim.

Delivery receipts and HTTP authentification have been contributed by Chteufleur.

Since the 0.6.1 version, messages handling has been improved, making now possible to implement features like last message correction, planed for the release.

Lastly, component (for gateways) and static blogs have also been implemented, but we'll talk about this later.


SàT is a huge project with strong ethical values (check the social contract), and it need help! It can be as easy as coming to talk with us (our room is at, also availble by clicking here).

If you can, financial aid would of course be useful, we have recently opened an account on the excellent Liberapay.

You can also join us in our association, all informations are available here

And of course contributions are useful, specially development but also translations, icons, CSS, etc. Most of the coding is done in Python, and working on SàT is working on a tool you may use everyday. You'll not find us on big centralised forges, but we are in the process of modernising our development tools (more to come on that).

Talk about our association and project around you is always useful.

I think the most important things have been said, I'll try to keep you up to date with shorted posts.

Oh, and the link with the pre-alpha version (once again: FOR TESTING PURPOSE ONLY):

March 13 2017

Tigase Blog: tigase-server project structure change

Previously, our main project, tigase-server has used a couple of maven modules (separate for the server sources, documentation and one responsible for building distribution packages). Unfortunately for equally as long, the file structure did not follow the standard maven structure.

March 08 2017

Tigase Blog: XMPP Summit 21 Reflections

The XMPP Standards foundation had its 21st Summit this past month in Brussels, Belgium just prior to a strong showing at FOSDEM in the same city.

March 02 2017

Erlang Solutions: 21 XMPP use-cases and the best ways to achieve them

## Who will find this interesting If you're considering XMPP for your project but you are unsure if it can provide the functionality you need, you'll eventually end up here: I'm pretty sure you'll be quite intimidated by such a long list of extensions. In some cases it will be pretty easy to find what you need. If you look for PubSub functionality, you'll quickly notice "Publish-Subscribe". Sometimes it's not so obvious though. XMPP developers already know that in order to synchronise outgoing messages between several devices, they have to enable "Message Carbons". Not very intuitive, isn't it? The aim of this blog post is to guide you towards proper XMPP technologies and solutions, given your specific use cases. I’ve worked with and deployed solutions powered by XMPP, such as [MongooseIM](, for years; so let me be your personal Professor Oak, providing a perfect "companion(s)" to work with and begin your journey in XMPP world. There are almost 400 XEPs, will you catch them all? ;) The length of this article is caused not by a complexity of descriptions but by a count of use cases and features. :) All numbers and information on implementation status are valid for March 2017. ### What can you expect here? For every use case, I will list XMPP features you definitely should consider using. Each one of them will be briefly described. The goal here is to understand the usefulness without reading whole specification. Besides that, each item will include MongooseIM's module name providing discussed extension and example client implementations. ### What you *won't* find in this post This post won't cover any XMPP basics. It assumes you either know them already (what are JID, C2S, S2S, IQ, stanzas, stream etc.) or you intend to learn them from some other guide, like the excellent (iOS) tutorial written by Andres Canal [Part 1](, [Part 2]( It's more of a cookbook, not Cooking For Dummies. ## ToC 1. I'm creating ...
1.1 ... a mobile application.
1.2 ... a desktop application.
1.3 ... a web application.
1.4 ... an application that just can't speak XMPP. 2. I need my application to ...
2.1 ... show message status like Facebook does.
2.2 ... provide message archive to end users.
2.2.1 I'd like to have a full text search feature. 3. ... display inbox (a list of conversations with unread count and a last message). 4. ... allow file transfers and media sharing between users.
4.1 P2P
4.2 File Upload 5. ... support groupchats ...
5.1 ... and I need precise presence tracking in each group.
5.2 ... and I don't need to broadcast presence information in each group. 6. ... be compatible with other public XMPP setups. 7. ... present the same view of each conversation on every user's device. 8. ... allow users to block each other. 9. ... support end-to-end encryption. 10. ... be a part of Internet of Things. 11. ... receive push notifications. 12. ... publish messages to groups of subscribers. ## 1. Creating ... Before we proceed to more specific requirements, it's important to identify crucial standards based on your application type. ### 1.1 ... a mobile application. Smartphones are omnipresent nowadays. It's a fact. The whole software market considered, mobile apps are an important medium between various companies and their customers. Some of them are the actual products (games, communicators, car navigations, etc.), not only a "channel". If you're going to develop a mobile application, you will need... **XEP-0198 Stream Management** It's an extension that provides two features actually. One of them is stanza delivery confirmation (both server and client side), what allows early detection of broken connections or malfunctioning network layer. The other one is stream resumption. It makes reconnection faster by reducing the round-trip count and relieves the client of fetching message archive as pending, unacknowledged messages will be retransmitted from server buffer. It is enabled by default in MongooseIM and supported by major client libs like Smack or XMPPFramework. From a client developer perspective, it's pretty transparent because the whole extension is enabled with a single flag or method call. **MUC Light, MIX, Push notifications, HTTP File Upload** These extensions are especially useful in the mobile environment. Why? With **MUC Light** and **MIX** you gain control over presence broadcasting - you can spare your users frequent radio wakeups and bandwidth usage. These extensions are a significant improvement over traditional presence-driven group chats. Virtually every app on our smartphones uses push notifications. Some are useful and some are just annoying commercials. It doesn't matter - it's almost certain you'll want them integrated with your XMPP service. HTTP File Upload allows asynchronous media sharing, which is much more convenient in the case of group chats and doesn't require both parties to stay online during the transfer. These are just brief summaries. You can find more details further in this post. ### 1.2. ... a desktop application. Despite mobile phones’ expansion and software products exclusive for them (Instagram, Snapchat, Tinder, etc.), nobody can deny the comfort of UI operated with a mouse, keyboard, or tablet. Some apps simply require processing power that portable devices can't provide. If your code is going to be executed on desktops PCs and laptops, you'll appreciate... There are no extensions that are strictly essential for desktop apps. Everything depends on specific applications. Just bear in mind that the standards important for mobile apps are generally useful for desktop ones too, only less critical. ### 1.3. ... a web application. As the days of heavy browser incompatibility (thank you, standardisation!) and Flash technology abuse are long gone, web applications are a great way to provide cross-platform solutions. It's not only easier to reach more platforms but also to ensure the users are always running the most up-to-date version. If you're a web developer, you're going to connect to the XMPP server via **BOSH** or **Websockets**. #### **Websockets** Websockets technology allow to upgrade an HTTP connection to an asynchronous, full-duplex, binary one (a bit of simplification but it's the essence). It means that XMPP stanzas can be exchanged almost as efficiently as over a raw TCP connection (Websockets add small overhead of integer with packet size). It's the recommended protocol for single-page apps. **Note:** You can combine **Stream Management**'s resumption with Websockets, although it will still be slower than BOSH's session **pause**. **Warning:** Websockets are not implemented by old browsers. If you have to support any outdated clients, take a look at [this table]( first. #### **BOSH** Defined in **XEP-0124: Bidirectional-streams Over Synchronous HTTP (BOSH)** and **XEP-0206: XMPP Over BOSH**. This protocol encapsulates XMPP stanzas in HTTP requests. It also simulates asynchronous, bidirectional communication by issuing long polling requests from client to the server to retrieve live data. What does it mean in practical terms? A persistent connection may be maintained but in general BOSH is designed to deal with interrupted connections. It's a perfect solution for web apps that trigger browser navigation. On such event, all connections made by e.g. JavaScript from browser are closed but the BOSH session survives it on the server side (not forever of course) and the client can quickly and efficiently resume the session after page reload. The protocol is pretty verbose though, so if you don't need this feature, go for Websockets. ### 1.4. ... an application that just can't speak XMPP. You probably think that I'm crazy; why use XMPP with XMPP-less clients? Let's change the way we think about XMPP for a moment. Stop considering XML the only input data format the XMPP server accepts. What if I told you that it's possible to restrict XML to the server's routing core and just make REST calls from any application? Tempting? It's a non-standard approach and it hasn't been documented by XSF (yet), but MongooseIM already exposes most important functionalities via REST. Check out [this]( and [this document]( to find out more. ## 2. I need my application to ... Now we continue to more specific use cases. ### 2.1. ... show message status like Facebook does. By message status we mean following states (plus live notifications): 1. Not sent to server yet. 2. Acknowledged by the server. 3. Delivered to the recipient. 4. Displayed by the recipient. 5. User is composing a message. 6. User has stopped composing a message. (1) and (2) are handled by **Stream Management**. It's pretty obvious - before receiving an **ack** from the server, you are in (1); and **ack** confirms the message entered state (2). We can deal with (3) and (4) by using **XEP-0333: Chat Markers**. These are special stanzas sent by a recipient to the original sender. There are dedicated markers for **received** and **displayed** events. (5) and (6) are provided by **XEP-0085: Chat State Notifications**. It is up to a client to send updates like `` and `` to the interlocutor. ### 2.2. ... provide message archive to end users. Virtually every modern chat application maintains conversation history both for 1-1 communication and group chats. It can remind you of a promise you've made, be evidence in a divorce case, or help in police investigation. XMPP provides two protocols for accessing message archives. The older one, **XEP-0136 Message Archiving** is used by hardly anyone, because it's difficult to implement and overloaded with features. It has been superseded by more modern **XEP-0313 Message Archive Management**, which is the current standard. There is one caveat though - its syntax changed significantly between versions, so it's common for libraries and servers to explicitly state what versions are supported by the specific piece of software. These are 0.2, 0.3 and 0.4(.1) and 0.5. MongooseIM supports all of them in `mod_mam` module. If you choose another server, make sure its MAM implementation is compatible with your client library. Smack and XMPPFramework use 0.4 syntax. #### **2.2.1. I'd like to have a full text search feature.** Although standard Message Archive Management doesn't specify any queries for full text search, it remains flexible enough to create such requests on top of the existing ones. In MongooseIM this feature is still in experimental phase and has been recently merged into [master branch]( It's not supported in any client library yet, so you have to construct a custom MAM query to do full text searches. Take a look at the [PR description](, It's not that difficult. :) ### 2.3. ... display inbox (a list of conversations with unread count and a last message). Unfortunately there are no open solutions providing this feature. XMPP community is in the process of discussing and creating the specification of Inbox functionality. Erlang Solutions is designing a XEP proposal, which you can view [here]( A quasi-inbox is available as a part of experimental standard **[Bind 2.0](**. It doesn’t cover all possible use-cases but a list of unread messages is what you actually need for optimal UX after establishing a connection. This feature is already under development in MongooseIM project. In the meantime, you can build an inbox view by persisting last known archived message ID or timestamp and query Message Archive Management for all messages that came later. When you fetch them all, you can build an inbox. Unfortunately this is not very efficient and that's why the community needs a new standard. ### 2.4. ... allow file transfers and media sharing between users. Almost everyone loves to share cat pictures and every modern IM solution provides means to do this. Various file transfer techniques in the XMPP world can be grouped in two categories: P2P connections and file upload. The former involves establishing a direct connection between two clients, sometimes with a bit of a help from a TURN server. It ensures that data won't get stored on any intermediate servers. Obviously, it requires less effort from the service provider because it's easier and cheaper to set up a TURN service than to maintain a proper media server (or pay for storage in the cloud). File upload is much more efficient when sharing media with a group. It doesn't require both parties to remain online for the transfer duration. #### **2.4.1. P2P** Now, you *DO* have a choice here. There are a couple of XEPs, describing various P2P transfer initiation methods. **XEP-0047 In-Band Bytestreams** (IBB) is guaranteed to work in every network, because it sends data (Base64-encoded) via IQs. So if you can reach the XMPP service, you can transfer files. It may be slow and not very convenient but it **will** work. Let's carry on. You can transfer media via bytestreams external to XMPP. The P2P session is negotiated via XMPP but it's only the "signalling" part. There are quite a few XEPs describing various negotiation and transmission protocols, so I will highlight specific implementations rather than listing all of the names which would only confuse readers who just want to send some bytes. * **XMPPFramework**: Look for `XMPPIncomingFileTransfer` and `XMPPOutgoingFileTransfer`. They support SOCKS5 and In-Band Bytestreams. * **Smack**: Everything begins with `FileTransferManager`. It supports SOCKS5 and In-Band Bytestreams as well.

#### **2.4.2. File Upload** Unless you already have a dedicated media server that exposes an API to perform uploads and downloads, you should definitely take a look at **XEP-0363 File Upload**. It defines standard stanzas to request upload slots and respective download links. It is XMPP server's responsibility to allocate the slots and return the links to the client. Unfortunately this extension is not widely supported yet. You can find it in XMPPFramework but not in Smack yet. In the case of MongooseIM, it’s already available with Amazon S3 backend (with more storage plugins to come!). ### 2.5. ... support group chats ... A couple of years ago it was really simple - there was only one kind of group chat supported in the XMPP world. Today we have three standards, two of them being maintained by XSF and one [published by Erlang Solutions]( MIX (XEP-0369), doesn’t have any implementations yet and as a standard it changes very frequently, so it is not described in this post. #### **2.5.1. ... and I need precise presence tracking in each group.** If you need IRC-like experience where users have certain roles in a room and client disconnection triggers leaving the room, then classic **XEP-0045 Multi-User Chat** will work for you. It has its disadvantages (frequent presence broadcast may impact UX and consume processing power or connection throughput) but fits the use case, where accurate presence information is important. It is provided by MongooseIM's `mod_muc` (other major servers implement it as well) and is supported by all mainstream client libs. #### **2.5.2. ... and I don't need to broadcast presence information in each group.** Erlang Solutions' **Multi-User Chat Light** is a protocol derived from real world use cases, where groups doesn't care about presences and full member list is always available to room members. It has some strong assumptions (like only 2 types of affiliation or rooms being joinable only by invite) but is designed to reduce round-trips, expose powerful API (e.g. room creation + configuration + adding new members in one request) and be easy to work with. [Check it out]( and see if it fits in your application. Server implementation is currently exclusive to MongooseIM (`mod_muc_light`) and respective plugins are available in Smack and XMPPFramework. ### 2.6. ... be compatible with other public XMPP setups. Even some proprietary installations do integrate with open XMPP world (like GTalk and Facebook at some point), so if this is your use case as well, the first important thing to remember is that no custom stanzas may leave your cluster. By custom I mean anything that is not covered by any XSF-approved XEP. Additionally, you will really benefit from using **XEP-0030 Service Discovery** protocol a lot, because you can never be sure what is the supported feature set on the other end. It is used to query both clients and servers. Virtually every client and server supports it. In case of MongooseIM, the base module is `mod_disco`. ### 2.7. ... present the same view of each conversation on every user's device. I use Facebook messenger on multiple devices and I really expect it to display the same shopping list I got from my wife on both my desktop and my mobile phone. It usually breaks message order but anyway - at least the list is there. The problem is actually a bit more complex, because you have to take care of synchronising both online and offline devices. Online devices can ask the server to forward all incoming/outgoing messages, even if they originate from or are addressed to some other resource of the same user. It is achieved by enabling **XEP-0280 Message Carbons**. On the client side it's easy - just enable the feature after authenticating and the server will do the rest. It's supported by MongooseIM in mod_carboncopy module. You can find respective implementations in Smack, XMPPFramework, and many others, since it's a very simple, yet powerful extension. If you want to fetch everything that happened while a specific device was offline for a while, just query **XEP-0313 Message Archive Management** (see "... provide message archive to end users." section). ### 2.8. ... allow users to block each other. You just can't stand your neighbour nagging you via IM to turn down the volume while Kirk Hammett is performing his great solo? Block him. Now. XMPP can help you with it. In two ways actually. Yes, XMPP features two standards that deal with blocking: **XEP-0016 Privacy Lists** and the simpler **XEP-0191 Blocking Command**. The former allows users to create pretty precise privacy rules, like "don't send outgoing presences to JID X" or "accept IQs only from JIDs in my roster". If you need such a fine grained control, take a look at MongooseIM's `mod_privacy`. On the client side it is supported by the likes of Smack and XMPPFramework. **Blocking Command** is much simpler but most setups will find it sufficient. When a client blocks a JID, no stanza will be routed from the blockee to the blocker. Period. MongooseIM (`mod_blocking`), Smack and XMPPFramework have it. ### 2.9. ... support end-to-end encryption. When Alice wants to send a message to Bob... no, we've all probably seen this classic example too many times already. :) There is no "one size fits all" when it comes to E2E encryption. The first tradeoff you'll have to make is to decide whether you want new users devices to be able to decrypt old messages, or do you prefer to have a property of forward secrecy. For a full comparison between available encryption methods, let's take a look at the table published by [OMEMO authors]( Legacy Open PGP Open PGP OTR OMEMO Multiple Devices Yes Yes No Yes Offline Messages Yes Yes No Yes File Transfer Yes Non-standard Non-standard Yes Verifiability No Yes Yes Yes Deniability Yes No Yes Yes Forward Secrecy No No Yes Yes Server Side Archive Yes Yes No No Per Message Overhead High High Low Medium
It's difficult to find an open library that supports any of these methods. Gajim communicator has an OMEMO plugin. Smack and XMPPFramework don't support E2E encryption in their upstream versions. If you're going to use E2E encryption in your application, most probably you'll have to implement it on your own. Good thing is there are standards you can base your code on. ### 2.10. ... be a part of Internet of Things. We are a peculiar bunch. We use semiconductors to build machines that do heavy number crunching for us, deliver messages in a blink of an eye and control robotic arms with precision far beyond ours. A desire has awoken in us to go even deeper and augment everything with electronics. To let **everything** communicate with each other. If you're designing a fridge microcontroller that is supposed to fetch results from bathroom scales and lock the door for 8h for every excessive BMI point, you'll need... * **XEP-0323 Internet of Things - Sensor Data** * **XEP-0324 Internet of Things - Provisioning** * **XEP-0325 Internet of Things - Control** * **XEP-0326 Internet of Things - Concentrators** * **XEP-0347 Internet of Things - Discovery**

Unfortunately there are no public implementations of these standards. I wish it was easier but it seems you just can't avoid reading these XEPs, picking the most suitable parts and creating your own implementation. To find out more and become an active member of XMPP IoT community, check out [IoT Special Interest Group]( ### 2.11. ... receive push notifications. Push Notifications are (usually) doing a great service to mobile devices' battery life. It is great indeed that a single TCP connection is maintained by OS, while apps can remain hibernated in the background. It is natural to every chat application to deliver notifications to the end user, even when a smartphone is resting in the pocket. How does XMPP cooperate with popular services like APNS or GCM? It depends. Although it's not difficult to find **XEP-0357 Push Notifications**, it deserves some explanation. This specification is **very** generic. It assumes the existence of another XMPP-enabled "App server" that handles push notifications further. Although implementations could be found (e.g. in MongooseIM or Prosody server), it is very common for commercial installations to use custom protocols to provide push tokens and send PN packets directly to the respective services (APNS, GCM, SNS...) ### 2.12. ... publish messages to groups of subscribers. Publish-subscribe is an ancient and extremely useful pattern. XMPP got its own PubSub specification quite early (first versions were published in 2003) and even though the protocol is pretty verbose (and a bit complicated), for the basic usage you'll need to learn only the most important aspects: there are nodes in the PubSub service where publishers can publish data. Nodes can group other nodes or remain plain leaves. That's the whole story. The rest is about configuration, access control, etc. **XEP-0060 Publish-Subscribe** is implemented in every major XMPP piece of software. In case of MongooseIM, it's handled by `mod_pubsub`. You can find in popular client libraries as well: Smack, XMPPFramework or ## Set sail! Now, if you feel brave enough, you can dive into this looong, official list of XEPs. These documents are designed to provide a precise information for libs and server developers. In your daily routine you'll probably won't care about every server-side edge case or whether some information is encapsulated in element X or Y. These are perfect reference guides for if you're stuck somewhere or need to tap into lib's plugin internals. I'd recommend one more intermediate step though. Browse servers' and clients' feature lists published by virtually every project on their webpages. They usually skip (or enumerate them in separate, more detailed docs) minor items and highlight the features that may be important to you. This way you'll expand your XMPP vocabulary and knowledge, while postponing the stage where reading XEPs is unavoidable, thus making the learning curve less steep. It won't be long until you realise that XMPP is your friend, I promise. :) Stay tuned for Part 2! In the meantime, you can brush up on your XMPP basics with our guide to building an iOS app from scratch using XMPPFramework (parts [1]( and [2](, or learn more about [MongooseIM](, Erlang Solutions’ XMPP platform.

Ignite Realtime Blog: Google Summer of Code 2017

For many years now, Google is orchestrating its "Summer of Code" program. GSoC aims to bring student developers into the open source community, during the summer holidays.


As it did before, the XMPP Standards Foundation (XSF) will act as an umbrella organisation for this years edition of GSoC. The Ignite Realtime community is open to accept students under this umbrella.


If you're a student and interested in working on one of our projects as part of GSoC, you should get in contact! We've prepared a number of teaser tasks as well as project ideas, all of which are available in the XSF wiki.

February 21 2017

The XMPP Standards Foundation: XMPP Summit 21

This year, the XMPP Standards Foundation again gathered in force to attend the summit, that traditionally precedes the FOSDEM event in Brussels, Belgium. Barely fitting in the (rather sizable) room that was made available to us by Cisco, the XSF members had a fruitful two-day meeting.

The attending members, skillfully herded by Kev, addressed an impressive number of topics, including:

  • BIND2, improving the data exchange that occurs when an XMPP entity initially connects to a server.
  • MIX, the XEP that intends to be a replacement for the existing MUC protocol, bringing an up-to-date feature set and better extensibility.
  • Addressing the annoyance of instant-messaging-based spam.
  • The application of existing, or to be developed XMPP standards, to facilitate the growing world of Internet-of-Things.
  • The XSF intention to take part in this years Google Summer of Code.
  • Improvements to the existing end-to-end encryption, as defined in the OMEMO XEP.

The full minutes are made available in the XSF wiki. If any of these topics (or others for that matter) interest you, we'd love to hear from you. Please find us at, use the mailinglists to contact us, or find us in one of the dedicated MUCs.

Many thanks to everyone involved in making the summit happen, including Cisco Belgium, Surevine, AG Software, Isode, Prosody, Erlang Solutions and Clayster for providing much appreciated sponsoring for the event, as well as the traditional XSF Member dinner!

Apart from the discussions, the summit proved to be an excellent opportunity for some of the newer members amongst us, myself included, to make acquaintance with the others. I, for one, am grateful to have been there, and am looking forward to the next meetup!

February 20 2017

Tigase Blog: Maven repositories URL changes

For quite some time we were using the basic mean to provide access to our Maven artifacts - simply serving them as a directory view. Recently we made some changes in that area to help with the maintenance and also provide a single access point to our repositories.

This resulted in deploying Apache Archiva under new URL:, from where you can access both final and snapshot repositories.

Ignite Realtime Blog: Request for Comments: Mavenizing Spark

Most of our projects have a long history. This certainly goes for Spark, which was created over ten years ago. Although many of you are actively using Spark today, it is beginning to show its age. This is something that we have been planning to address for a while now.


Spark was created around the same time that the Kyoto protocol went into effect, Pluto got demoted to the status of 'dwarf planet' and Italy won the FIFA world cup in Germany. Thereabouts.


Comment.jpgSince then, source code development tooling has improved a lot. Today, the Spark project is struggling to find active contributors. We believe that one of the reasons for this is that it's pretty hard for developers (especially those that are used to work with modern tooling) to get started with our project. We have been working on that. First, we moved all of our projects from our old Subversion repository to Github. We have noticed that this dramatically improved the accessibility of our code. Second, Smack 4 happened, bringing the backbone of Spark back up-to-date.


Now, we are addressing the structure of the project itself. We will restructure the project as a Apache Maven project. This will bring a good deal of predictable structure to the project, which has many benefits. One of these is that the project will integrate easily with various development tools.


Moving Spark from its existent Ant-based structure to a Maven structure is no small task. There is no one right way of doing this. We have given it a shot, and have created a structure that we think is very workable. Before committing to this structure, we would very much invite others to have a look, and comment on what we've done. The reasoning behind this is simple: once we've committed to a particular structure, it will be disruptive to change it. If we want to apply improvements, we should do so now.


Please, review our new project structure, and let us know what you think. You can find the new structure in the SPARK-1791_Maven branch on Github.


Ask yourselves: does this structure help me? Is it easier to compile the source code? Can I integrate it with my IDE of choice without too much trouble? Can I create new plugins? Does the new structure introduce a problem that needs to be addressed before committing? Can it be improved? We welcome all feedback!

February 19 2017

Peter Saint-Andre: Going Deep

Three months ago, in a post entitled "Below the Surface", I started a habit of posting in my weblog at least once a week. Although it's been a good run, I've cleared out my backlog of topics to write about. More importantly, I have a big project to finish (The Upland Farm, my forthcoming book on Thoreau) and another one to restart (more on that in the coming weeks), not to mention the need to focus intently on building the team at Filament and bringing our products to market. Because all of these initiatives will require a lot of deep work, my weblog will likely be fairly quiet until mid-summer. See you then....

February 18 2017

Ignite Realtime Blog: Openfire 4.1.2 Release

The Ignite Realtime Community is pleased to announce the availability of version 4.1.2 of Openfire. This release signifies our ongoing effort to produce a stable 4.1 series while effort is made on new features and functionality in Openfire 4.2.  You can find a release changelog denoting the 13 Jira issues resolved in this release.  If you had issues with inconsistent appearance of groups, do please test this release to see if those issues are now resolved. You can download the release from our website here and the sha1sum's for the available artifacts are as follows.


OS sha1sum Filename Version 4.1.1 Downloads [1] Linux RPM (32bit JRE bundled) c2f12c3ec6ba2f64388279f106f2749272c9504c openfire-4.1.2-1.i686.rpm 1290 Linux RPM (no JRE) 226a7f1138fda7c456523bf80e6140e020fd5a74 openfire-4.1.2-1.noarch.rpm 965 Linux RPM (64bit JRE bundled) 6892ec82e1435b6cbf23da1ba1efb9d94122d8a6 openfire-4.1.2-1.x86_64.rpm 3805 Linux .deb c205eefe136fe0481e498668f258a0bc724a7080 openfire_4.1.2_all.deb 7311 Mac OS dmg b9570c78854c226714c23001997119e503e0aaab openfire_4_1_2.dmg 1207 Windows EXE dba34e78456f03bbd0de5a5cf94730c433d75c20 openfire_4_1_2.exe 19798 Binary (tar.tgz) cf4676f1e8c8a04999f6e9c97d859c8bbff35c4e openfire_4_1_2.tar.gz 2622 Binary (zip) 0f4624f2c387c00373c717a52ed442741ceb0e93 3058 Source (tar.gz) 9b1efd5090ff37e4faca6d460b20ec40a4c40a53 openfire_src_4_1_2.tar.gz 408 Source (zip) b32c39ec84ad04acf46881b682919ef41fab3be4 1371


[1] We recently migrated to storing our release artifacts on Github and thanks to their API, we can get metrics on how many times the artifact was downloaded.


As a reminder, our development of Openfire happens on Github and we have an active MUC development chat hosted at . We are always looking for more folks interested in helping out, so please consider pitching in!


As always, please report any issues in the Community Forums and thanks for using Openfire!

February 12 2017

Peter Saint-Andre: Forever Jung

Recently I got to talking with a friend about personality assessments, especially in relation to hiring and talent development. It took me awhile to figure out why we were not in agreement: he was thinking about the Myers-Briggs Type Indicator (MBTI) whereas I was thinking about assessments based on the five-factor model (also called the "big five") of personality traits....
Older posts are this way If this message doesn't go away, click anywhere on the page to continue loading posts.
Could not load more posts
Maybe Soup is currently being updated? I'll try again automatically in a few seconds...
Just a second, loading more posts...
You've reached the end.

Don't be the product, buy the product!