Easy to use software Documentation Builder

I`ve created this product because I always struggle with generating documentation in HTML or Word format.
It is just a bit boring to make a menu and all the connected sections. Also, there are always so many revisions you end with 10 different files.

So I create an online tool to build the navigation and storing the text after I quickly add my
navigation and text I can share the URL to the product or export it to PDF.

Also, I can manage all the revisions in one place

It just saves time and boring stuff to do every time you lunch a new product.

Check it out: https://create-documentation-online.com/

Source link

Design systems supercharged

Building great front-end products is hard and time-consuming.

Web technologies are evolving at high pace, designers and developers struggle to collaborate on handover, building consistent web components requires loads of works, documentation is too often not up-to-date, maintaining apps over time is an Herculean task, …

You know the story.

Implementing a Design System is a good solution to tackle these challenges. The Design System is the source of truth for all reusable tokens and components to be consumed in web apps. Building and managing a Design System, as a part of a production pipeline, will greatly improve team efficiency and product consistency.

A good Design System should help teams collaborate, improve reusability, manage technologies evolution, build documentation, ship faster / better, and lower maintenance. But building and maintaining the tooling to manage a Design System remains quite time consuming too …

That’s why we launched Backlight.dev, a powerful and collaborative platform to build Design Systems on the code side. Backlight helps front-end teams to deliver value by focusing on their real work, not on maintaing tools.

Backlight comes with some nice features :

  • All-in-one : tokens, components, code, stories, tests, documentation, designs, …
  • Technologies / frameworks agnostic
  • Real-time preview rendering for tokens, components and documentation
  • Real-time and asynchronous collaboration
  • Live documentation (MDX with embeded components and code snippets)
  • Versioning and repo management with Github / Gitlab / Bitbucket
  • Code review and visual diff for Pull-Request
  • NPM package export
  • In browser or local CLI
  • No tools or pipepline to deploy / manage

And best of all, we have a free plan to test Backlight.

Let’s give it a try ? 🙂 Start now

Front-end is for heroes. At ‹div›RIOTS, we believe front-end is a beautiful challenge and we are on a mission to empower front-end teams with great tools. Backlight is one of them. We also launched some free sandbox products to play with web components and tokens (check them out here).

Source link

Different features on DEV and FOREM?

I recently discovered FOREM and it turns out that FOREM is like a same thing with DEV, but I’m still confused about what the difference is? Which is better in terms of features, community and more?

Because it’s not appropriate if a programmer / community / organization has many blog sites with all the same posts, I think instead of wasting time writing / recopying, it’s better to focus on 1 platform, but maximized in creating content.

I still don’t know much about FOREM and DEV which is better, built first and how big is the community between them? I hope someone can help me with this problem and from this article it can help our friends who are still confused about which one is better.

Source link

Open Source: As explained to a five-year-old

It is Christmas, and Daddy brings home a Christmas tree, and the tree needs to be decorated. You have lots of decoration ideas, same as your sister, but you cannot decorate the tree till you receive permission from your Dad. Until permission to decorate the tree is granted, you cannot decorate the tree. This is similar to the way open source works.

So what could Open Source mean?

Open source is the source code of computer software that is accessible to the public to change, redo, remake only when permission is granted.

How does that work?

In the development process of that software, publicly making it accessible is considered so that when the software is released, anyone can have access to it through a means of permission. Github is where open source projects are mostly uploaded so they can be made available to the public. From Github, there are repositories where you can get the project to use the code or contribute changes to the software.

The permission given to open source is called License . This License contains conditions where the actual owners of the software state how exactly they want you to use, change or modify their software. Some of these licenses could include MIT license(MIT), Apache License 2.0, GNU General Public License etc.

Open Source Software are most preferred because they are interested in having more control over these kinds of software. Examples of Open Source Projects include; Linux, Mozilla Firefox, Apache, WordPress, VLC Media Player etc.

Why the need for Open Source?

Contributing to Open Source has lots of benefits, and they are

  1. Open Source Software tends to have fewer bugs than regular software.
  2. Open source helps owners do a global software product for little to free cost.
  3. It encourages collaboration amongst the Open Source Communities.
  4. The source code is made available to the public to understand its purpose or how it works and how it works.
  5. It promotes the exchange of knowledge, allowing for more people to become skilled software developers.
  6. Since it is made public for modification, it meets all the criteria of the public.
  7. It is free.
  8. Open Source Software is highly secured because developers constantly review the code, thereby ensuring security and accountability.

Source link

One Commit. One Change.

Why a small atomic commit is easier to work with

Originally posted on May 05, 2016.

A few weeks ago I attended a series of 3 talks from Martin Fowler in Australian Technology Park, Redfern, Sydney. One of the talks was about deriving the application state from a sequence of persisted events. A.K.A Event Sourcing:

[…] The fundamental idea of Event Sourcing is that of ensuring every change to the state of an application is captured in an event object, and that these event objects are themselves stored in the sequence they were applied for the same lifetime as the application state itself.

That talk reminded me a lot about Git, which is built using the principle that if you replay all committed changes since the beginning and in the same chronological order, you will get the exact same result. The current state.

In Git, if you replay all committed changes since the beginning and in the same chronological order, you will get the exact same result.

However, Git is just a tool. It is the responsibility of the engineer to use it in a way that brings the most valuable possible outcome. One of these responsibilities is taking care of how changes are inserted into the VCS, creating a commit which purpose should reflect one change and one change only. Also known as an atomic change.

As from the emacs manual, in database terminology, an atomic change is an indivisible change — it can succeed entirely or it can fail entirely, but it cannot partly succeed.

In Git, it means that a change should be able to be reverted (git-revert) and not cause any side effects or conflicts in other parts of the system other than the one that is being reverted. Also, it should contain a single change that doesn’t have real value if applied partially.

An atomic commit should be able to be reverted or applied without side effects.

Another important point about atomic commits is the fact that it should not break the normal flow of your build, it should just remove or add something cleanly. If you have a build routine or tests, you should be able to run it successfully whether the commit is there or not, just by assuming a specific set of premises. “Premises” in this context represents the required state of the codebase in which the commit can be applied with the least amount of code conflicts.

This is more important if you are committing into the master branch, the one branch in which the history should always be in a consistent and immutable state.

An atomic change is a piece of functionality that can be replayed over and over again against a specific set of premises.

Not breaking the build is an important aspect of atomicity, because then it is possible to reset your application to any state in order to see how the application was working at that time. It is also possible to easily leverage built-in tools to find bugs in the history (such as git bisect), something that can’t be easily done if one can’t run the build after a reset.

As the last point, we have the principle of traceability of changes. Ideally one should be able to track the whole source and purpose of a change through the history of the commits without having to talk with the original author, because he or she might not be available anymore or not even remember what that change was all about. If a commit does more than one thing, it might be impossible to understand in the future why those lines in the system were changed.

If a commit does more than one thing, it might be impossible to understand in the future why those lines in the system were changed

If you create commits with more than one change, it will be hard to find the point in time in which a mistake or feature was introduced in the codebase, it will be hard to reset the codebase to a previous state, and might be impossible to revert a modification without side effects.

This is a principle, not a law. Be thoughtful and make the best decision given the circumstances.

See also One Pull Request. One Concern.

Thanks for reading. If you have some feedback, reach out to me on Twitter, Facebook or Github.

Source link