Why Blasma

I will explain why I am developing Blasma, what the goals are.  Blasma is largely an attempt to start over and avoid the mistakes that I think were made with Nabble.

In response to many requests for customization of Nabble, we developed NAML which is the scripting language for Nabble.  I consider NAML to be a failure.  It is too complicated for most users, and at the same time lacks the power to really implement new features that users may want.  There are two kinds of customization, visual customization and new features.  These are different and should be handled separately to avoid the problems of NAML.  For visual customization, Blasma uses a theming system similar to Tumblr's.  This is much simpler than NAML.  This theming will also support responsiveness, so a theme can be conditional based on window width.  Responsiveness is missing in Nabble.  Theming contains no programming statements, which makes it simple and safe.

For new features, I am taking a very different approach from Nabble.  Blasma is open source with strong support for modules.  This means that anyone who wants to add a feature can simply program it as a module.  And this is safe because I will review any submitted code before releasing it.

Regarding the feature set, my plan is to develop those features which I want or are popular.  If a feature doesn't meet either of these criteria, I won't develop it, but anyone who really wants it can add it themselves.  The themes choose which features/modules they will support.

Another conflict I am trying to resolve with Blasma is the conflict between quality and what customers want.  Because modern culture is depraved, customers generally want very bad designs.  Themes resolve this conflict as well.  I will design the first theme based on quality, but users can develop depraved themes which will be popular and I will include these in Blasma.  The list of available themes will be sorted by popularity.

One other issue is standards.  I used to be a big advocate of adhering to standards before modern culture became depraved (basically last century).  But now that modern culture is depraved, the standards that are being released are horrible, so now I intentionally ignore standards.  Blasma is programmed in Luan which is a language that I developed based on Lua.  Luan goes against all modern trends and is extremely simple and understandable.  Modern HTML is also a horror.  So my theme violates all modern HTML rules and again aims at being simple and understandable.  I assume that modern users won't like this, but they are free to develop themes that adhere to modern standards.

Nabble grew over time and became too complicated.  My goal with Blasma is to keep it simple while aiming for quality and flexibility.  So my goals for Blasma, in order, are simplicity, quality, and flexibility.

Hello,

I am interested in getting involved in the Blasma project.

Don't want to bother you devs, but I would be happy if you could provide some further information. Please have a look at my questions.

(1) You say, the programming interface of Nabble was too complex for the majority of users. So you intend to separate the two main development activities: the "visual design" of a site and the "implementation of functionalities". Are there already interface descriptions for both activities? How could I start to develop my own theme? How would I proceed to implement a new functionality and attach it to the Blasma system? What is LUAN's role here?

(2) Is there some documentation that explains the difference between LUA and LUAN? How do the modifications effectively facilitate the application within Blasma?

(3) Suppose, I'd like to execute Blasma and play around with it a bit in order to finally be able contribute some features or designs. After I got the code from BitBucket, what other things would I have to install on my system (Windows, Linux,...) in order to have everything in place? I saw that all files have the extension ".luan", which I haven't seen so far. And what would the installation process look like? What system requirements would I have to provide in order to get everything up and running?

fschmidt wrote

Nabble grew over time and became too complicated.  My goal with Blasma is to keep it simple while aiming for quality and flexibility.  So my goals for Blasma, in order, are simplicity, quality, and flexibility.

Great! I like that. Hope that this goal will be hit.

Thanks for your support.

Regards
Nnako

I don't have much time right now for Blasma, but I will answer your questions.

Blasma is written in Luan.  The "visual design" is handled in themes which are similar to Tumblr themes.  The "implementation of functionalities" is done by adding modules directly into the Blasma source.

Luan is documented here:

http://luan.luanhost.com/

This includes an explanation of the difference between Lua and Luan.  Luan is designed to be general purpose but I mostly use it for web projects.  It is simpler than Lua and faster and fits better with web serving.

To run Blasma, you need Java and Luan.  That's all.  But scripts are for unix, so Linux would be easier than Windows.

Now I have some questions.  Why are you interested in Blasma and what are your strengths?  I ask because if we can work together on this, I would consider becoming active again.  My main weakness is UI.  I have no sense of aesthetic design.  If you are good at HTML and CSS and designing themes, then maybe we could work something out.

Hi,

thanks for your quick reply,

fschmidt wrote

Why are you interested in Blasma ...

In my private life, I like to support my friends and their communities. Especially small churches, small businesses or other interest groups have a strong need for communication and information management. On my quest for technical platforms, I ran into Nabble about two years ago and was convinced that its concept was perfect. To get involved, I (together with another fellow) provided its German translation and became a power user over time, trying to adding / modifying features using NAML. Unfortunately, in the end, I was not able to get the necessary information concerning NAML. The language documentation was nice but too basic (more complex issues could not even be solved using the support forum):

- general usage information
- general parameter handling
- handling of specific variables
- ...

I even wrote a kind of status report to encourage the provision of more specific help on NAML or at least get me involved in providing such thing. But in the end I had to resign and just use Nabble as is.

I think, Blasma could become what Nabble intended to be. With clear and well documented interfaces for users, designers and developers. So, I'd like to get involved in developing it.

fschmidt wrote

... and what are your strengths?

Unfortunately, I am no designer. Although I know HTML, CSS and a bit of JavaScript, I would not regard myself as being the right person to shape the outward look of Blasma. I have some friends (photographers, web designers and artists) who could have a look and give general advice or specific hints. Those could be taken into account and implemented. I would call my main strength "structure". I strive for:

- clarity in program structure
- clarity of information flow
- helpful and detailed usage documentation
- clear requirements engineering
- clean interfaces between functionalities (modularity)
- ease of use regarding different roles (user, designer, developer)
- ...

Here are some of my "personal features" which could be relevant for the Blasma project:

- knowledge of many different programing languages and programing styles
- strength in building development environments (to minimize waste of time)
- strength in information management techniques (e.g. mindmapping)
- strength in code management (version control, auto structure documentation)
- strength in requirements engineering and task management
- a strong will and an open mind for learning new technical things
- ...

Like you, I have just very limited time. And I want to spend it as efficient and effective as possible on personally favoured projects. This is why I am looking for projects which are well structured (or at least where the main developers are not opposed to well structured development). Without a good development structure, people in the end tend to spend their time searching for information instead of spending it on the actual development.

Hopefully, I could get you interested. ;-)

Please don't hesitate to ask further questions and get me involved.

It sounds like your skills overlap with mine rather than complement mine.  So there are 2 issues: who will do the UI and would we agree on what you call "structure"?

For UI, I had been working with Alex but he doesn't do anything technical.  This meant that I had to implement his designs which is very inefficient.  I want a UI designer who can edit themes on his own.  Without this, I don't see how any progress can be made.

By modern programming standards, I am a heretic because I disagree with most modern programming ideas.  I will give some examples:

I am against multiple paradigms in programming languages.  A programming language should support one paradigm in the cleanest and simplest way possible.  So for example, one can support object-oriented programming through classes or through closures.  No language should support both.  Java was clean initially and only supported classes, but now supports closures, to my disgust.  I picked Lua as the base for Luan, but the Lua ":" operator is basically to support class-like programming, so I removed this feature from Luan.  Simplicity means above all conceptual simplicity - the fewer concepts, the better.  This is in direct conflict with modern culture which loves needless complexity.

The separation of interface from implementation is critical in the interface to a layer, but is actually harmful inside a layer.  In other words, some function in blasma that is just used by other parts blasma should simply be an implementation.  Defining a separare interface and implementation is harmful because someone reading this code usually wants to see how functions are implemented, and a separation just makes this more difficult to follow.  And of course writing a simple function is the simpler approach.

I believe in strong layers far more than I believe in other kinds of modularity.  The layers of blasma are:

theme - blasma - luan - java

It is critical that functionality be put in the right layer, and that each layer provide a clean interface for the layer above it.  But within a layer, code should be as simple as possible, and one should break all the other rules to favor simplicity.  Within a layer, modularity just means that code is well organized.  Dependancies within a layer are fine because if you change X and it breaks Y, you can just fix Y.  That is preferable to complexity.

Of the 2 issues, the UI issue is the critical one.  With limited time, I will only work on blasma if I can do it efficiently, which requires a UI person.  Blasma has a very clean system of modules which means that you could easily add functionality to blasma if you wanted to, but there is no point without a UI person.

Hi,

I saw that all the posts are about 1,5 years old :-( , so I was wondering if the idea of moving NABBLE one big step forward has been extinguished. This would be very sad, as I still see great potential in forum development and the concept of using an "easy" language NAML (or a similar one) for user-driven modifications.

@fschmidt: Let me catch up with your last post, where I had the impression I was in the end not welcome to participate because I was not an 100% UI person. Which I can understand in a way.

As far as I understood, what you said about

(1) PROGRAMING LANGUAGES  -  means by which functionalities are implemented
(2) LAYERS  -  in a way role-specific containers for function modules
(3) MODULES  -  the actual functional/interface units interacting with each other

Regarding (1)
I think that a pre-requisite for building a successful development team and working together should be an AGREEMENT on which kind of concepts from a chosen programing language (using classes or closures, using globals or strict function parameters,...) is to be found. Not so much to pick a feature-poor language in order to ensure a certain kind of programing paradigm. But to conciously restrict usable features in order to gain ease of development among possibly not-likewise-minded developers.

Regarding (2)
I agree. A clear "structure" (like when building a house with different layers) seems essential to me as well. But I would even prefer "interface clarity" over "simplicity" which could locally lead to implementation "complexity" when restricting oneself to the agreements of (1). These layers should all have clear and well-structured sections (rooms on each layer) with stabile "doors" for information to flow in a very coordinated way between the modules.

Regarding (3)
Modules are the ingredients (or information generating/consuming/exporting members) within each layer / section. A change of implementation of any module should NEVER lead to a break of functionality within another module. To achieve this, clear and simple interfaces between modules are to be defined BEFOREHAND which are in sync with the overall structure and give maximum freedom for data in- and output. In the long run, as the code base grows, necessity for bug-fixing within foreign modules might otherwise get ahead of the actual development necessities.


So, are there any sketches about the "structure", yet? Containing layers, sections and maybe the interface definitions for modules? Regarding your last post... e.g.

- how does the "blasma" layer look like?
- how is it connected to the other layers?
- how is it structured? What/where are the core-parts, where the user-modifyable parts?
- how does a user access the user-modifyable parts?
- ...


And what about the things that went wrong with Nabble? Is there a feature list which is to be implemented when realizing Blasma? ... e.g.

- which parts (features) of Nabble should be dropped? And why?
- which parts (features) of Nabble should be re-newed?
- which features would be new within Blasma and what benefit would they bring?
- ...


And... what do I have to do in order to set up a working development environment? ;-)


I'm still very much interested in investing my time in a forum system based on the idea of Nabble / NAML. And I would like to get started in a practical but STRUCTURED way. If there is any chance, please let me know. I could even help creating structure overviews which might help in documentation and development revevant discussion.

When I wrote the last post in this thread, I assumed that I would be writing Blasma.  But since then I have been pulled into other projects.  So I am open to the idea of someone else taking over the coding of Blasma as long as they do this in a style that I can read and tolerate.

Regarding your comments and Nabble.  Nabble is written in Java and I worked with someone else who used the new features Java to make the code unreadable.  In general, people are horrible and can always be trusted to do the wrong thing.  This is why religion is needed to keep people in line.  And this is why a good language is like a good religion, and restricts programmers to try to prevent them from writing horrible code.  I am not sure what 'prefer "interface clarity" over "simplicity"' means since I view clarity and simplicity as basically the same thing.  Simplicity doesn't mean short code.  It means code that is simple to understand which implies clarity.  The importance of defining module interfaces depends on the nature of the project and the module.  If a module is not used by other code, then its programming interface isn't very important.  So I think this needs to judged on a case by case basis.

Blasma is a new project not based on Nabble.  It is open source which means that anyone can add the features that they want.  So I think that Blasma should start as small as possible and then features be added based on user's needs.

If you are really interested in working on Blasma, you can start by reading about Luan.

http://luan.luanhost.com/

The Blasma source is here:

https://bitbucket.org/frschmidt/blasma

This code is old.

Please think this over.  If you are serious about working on Blasma then we should talk.

Time to update this thread.

The core value proposition of Blasma is to be a configurable social forum.  Right now popular stand-alone forums are configurable but not social, and social forums are not configurable.  Based on the stand-alone forum market, it is clear that forum owners want to be able to configure their forums.  But it is extremely difficult for forums that aren't social to attract users.  Blasma can offer the best of both.

Blasma should be a free speech platform, but this will only help to get a few forums from Reddit refugees.  Modern scum generally hate free speech, so free speech won't make much difference for Blasma in the long term.

Nabble users can be encouraged to switch to Blasma which will help it get off the ground.

I am not sure exactly how theming should work, but there should be at least 4 themes at launch: reddit theme, classic (like phpbb) theme, fschmidt theme, and bas theme.

Most of the current complexity in the Blasma code is to support modules and themes.  But this makes Blasma more configurable than any other forum, so I think it is worth it.

Assigning to bas to read this thread.