Check what's new around sensenet. You can find posts about new and upcoming features, related topics and many more on sensenet blog.

sensenet blog

blog

posts

News around sensenet

As a result of our [design sprint](https://www.sensenet.com/blog/2021-03-24-sncom-design-sprint) (back in april), we found that most people don't really like to share any personal details (even an email address) to try out a new solution.

This is where a [live demo](https://www.sensenet.com/tryit) comes in handy since you don't need to register to check if a product fits to your needs.

We always had a demo for this purpose but we've never been happy with it. After some user interviews (during the design sprint) we had the confirmation of the importance of this topic so we decided to dig deeper and fine-tune the experience. 


<img src%3D"https://raw.githubusercontent.com/SenseNet/sncom-resources/master/img/posts/tryit_page.png" alt%3D"try it page">


Once this was clear to us we started to gather ideas to understand and make the journey of a user more seamless. We already had every piece for that (website, try it page, example apps, demo repo) however the whole thing did not came together as a smooth experience.

During an evaluation it is crucial to get the most possible information and to have a complex image of the solution by the the of the day.

The concept was to logically connect the [example apps](https://docs.sensenet.com/example-apps) to our demo repository and by this, to demonstrate how a simple app works with sensenet.🤔

Since the demo repository already contained every content used by our example apps (images, tasks, events, etc.), we made the connection clearer for our users with links and buttons in the apps pointing to app-specific content in the repository.


<img src%3D"https://raw.githubusercontent.com/SenseNet/sncom-resources/master/img/posts/linksNbuttons_exampleapp.png" alt%3D"example app link and button">


We also revamped the whole [example apps](https://docs.sensenet.com/example-apps) page on [docs site](https://docs.sensenet.com/) to be more structured and added some extra information explaining the logic behind these apps.

As a final step we simplified the access to each part of the experience:
- Example apps can be reached with automatic sign-in, removing every additional steps from the process
- Demo repository became more accessible as well, since everyone can get in through the admin ui with a single click.

The final solution is what we call the [demo experience](https://www.sensenet.com/tryit), and we hope that everyone can get a taste of sensenet more easily (without registration 😉😎). Try it and share your thoughts!

If you already convinced, you can skip this step and get your own repo [here](https://profile.sensenet.com/?redirectToLogin)!

No registration, one click logins, and getting the big picture! This is what we call demo experience. 🦄🌈

2021-05-26-demo-experience

Presenting the new demo experience

## What is a webhook

In short, using a webhook is a great way for your application to receive events or notifications from a service.

In terms of sensenet it means your repository can send notifications if something happens with a content. You can configure these webhook subscriptions as you wish, you can set what type of content, which subtree, and what specific events to work with and of course you can set the scope of the data (payload) to be sent.

Webhooks can not only notify your app about what's happening in your content repository, but also builds up connection between sensenet and your favorite external services. They can be used in many very different cases from sharing information in social media about content changes till rebuilding static websites automatically.

## Triggering static site builds

Once you've setup a static site that pulls in your content during the build process, you're ready to configure webhooks that will be triggered when you are working with content in your repository. The next example teach you how to setup webhooks to trigger builds and deployments of static sites on Netlify, but this is just an example. sensenet of course provides you various other options for Heroku fans, Travis CI users and Gatsby Cloud subscribers among others. Check currently available templates [here](https://docs.sensenet.com/integrations/webhook). Webhook templates help you create webhooks subscription for specific external services with just a few steps, by filling only a few required fields. Following example will teach you how to configure a webhook to trigger a Netlify build with a few steps.

## Configuring a Netlify build hook

First, go to your static site on Netlify and create a build hook for sensenet (it can be found under *Site > Site settings > Build & Deploy > Build hooks*). This will be the url that builds up the connection between your repository and the static site.


<img src%3D"https://raw.githubusercontent.com/SenseNet/sncom-resources/master/img/posts/netlify-build-hook.png" alt%3D"Netlify build hook">


Then create a new webhook through sensenet admin ui (*Settings > Webhooks*) choosing Netlify template:


<img src%3D"https://raw.githubusercontent.com/SenseNet/sncom-resources/master/img/posts/netlify-webhook-template.png" alt%3D"Netlify build hook">


There are two required fields on the form to fill out: *Name* and *Netlify build hook URL* (the url you've created above at Netlify *Build and Deploy* page). You can leave all other fields at default (you can change them at any time later) and that's it.

By default, this webhook will:

- Trigger a Netlify build
- Triggered when something is happened with a **File** type content under **/Root** container
- Triggered on all available events (Create, Modify, Delete, Checkout, Draft, Approve, Pending, Reject)


<img src%3D"https://raw.githubusercontent.com/SenseNet/sncom-resources/master/img/posts/new-netlify-webhook.png" alt%3D"Netlify build hook">


From now on, if a file is uploaded to the content repository your Netlify site gets built and deployed automatically. Many other webhook templates make it easier to work with external services and sensenet, and of course you have the freedom to configure a webhook as needed for your own project. 

If you don’t have a sensenet repository, now is a great time to [sign up](https://profile.sensenet.com/?redirectToLogin)!

Integration is a key aspect of digital projects, since preferably, all services used in a project should be connected and work together seamlessly. With sensenet webhooks and the built-in webhook templates it's super easy to achieve such goals. Let's see how!

2021-05-13-automate-static-site-builds-with-sensenet-webhooks

Automate static site builds with sensenet webhooks

## Delivering release notes and updates

Since we are working on our new SaaS model we are constantly thinking how could we improve each and every part of the service. For this reason we made a [design sprint](https://www.sensenet.com/blog/2021-03-24-sncom-design-sprint) to better understand the user journey and we are currently working hard to make our demo experience more seamless.

Content creation is also top priority, so we write documentation, tutorials, blogposts and so on. But how can we share these new stuff with our users more effectively?

Until recently we pubslished our release notes on GitHub and we also generated two pages from them ([frontend updates](https://www.sensenet.com/frontend-updates), [backend updates](https://www.sensenet.com/backend-updates)) to be easily accessible from our website. This method was good enough to start with (and still exists) but we seeked for a more elegant (and useful) solution.

We found a promising tool on [producthunt](https://www.producthunt.com/). The app is called [Olvy](https://olvy.co/) and it was #1 product of the day (back in 27 February) that's how we found it.

We've added it first to the [admin ui](https://docs.sensenet.com/guides/getting-started) - a central place to manage sensenet repositories in the SNaaS model - to share useful information with our users, such as release notes, new and upcoming features.

We were so amazed by this new solution that we've included it to each public websites and apps we have.


<img src%3D"https://raw.githubusercontent.com/SenseNet/sncom-resources/master/img/posts/olvy/bellvariations.png" alt%3D"olvy integration">


Here we would like to mention that this is not a paid promotion, we only want to write about our experience with this service. We paid full price for Olvy altough we took advantage of the early bird discount.🐣😊

The integration part was quite easy, we just had to add a small code snippet into the admin ui and tag a button with the appropriate id, that's it.

## How it works?

Olvy has a simple user interface which can be used by anyone (sales, marketing, devs) to share content in no time. You can build your post in a rich text editor, attach featured link and image to it (so it will be more appealing). Set scheduled publish and/or expiration date to make your life a bit easier.

Users see new updates as a colored badge whenewer you want (see variations above) and by clicking on the button a sidebar reveals containing all previous "releases". It is possible to get comments and reactions as feedback from your users.


<img src%3D"https://raw.githubusercontent.com/SenseNet/sncom-resources/master/img/posts/olvy/olvy-ui.png" alt%3D"olvy user interface">


Olvy has even more features like [standalone page](https://sensenet.olvy.co/) for releases and more to discover in the future.

For us this is the ideal solution to share info about our new releases like new features, fixed bugs and so on (both frontend and backend). As mentioned above, you can still reach our releases [on our website](https://www.sensenet.com/backend-updates) and [GitHub](https://github.com/SenseNet/sn-client/releases) as well, but now you'll be notified about any news around sensenet immediately once you visit our public websites or apps.

We are getting familiar with producthunt recently as we want to launch our new SaaS model there. By chance we came across a great tool which saved us some dev hours. Here's our experience.

2021-04-28-hey-olvy-whats-new

Hey Olvy, what's new in sensenet?

We will examine through a real example how they work and how we can make our web application faster by reducing our initial bundle size. It is common to use TypeScript for its static type system. We often need types from our dependencies, but if we don't pay attention it can ruin our hardly achieved code splitting. I will show you a fairly new syntax to avoid it.

## Dynamic import

Dynamic import has reached the stage 4 of the TC39 process and is included in the ECMAScript 2020 language specification. Webpack, currently the most popular JavaScript module bundler, already supports it since the v2 which was released in 2017. It makes it possible to load parts of your application at runtime. Maybe you use a heavy dependency only on specific cases or you want to load only the desired localization files on a multi-language page based on the user's preferences. This way you can make your site more performant and lightweight at the same time.

The syntax of the dynamic import is quite simple, it just extends the import keyword by making it possible to use it followed by parentheses with the path of your dependency in between.

```javascript
import('module/example').then(example %3D> console.log(example.default)
```

> This sytax looks like a function call, but it is not. Import is not defined as a function, it is a specific operator.

The code above loads the module at runtime and logs its default export to the console. This is just a basic example, you can use anything exported by the module in the callback function or load multiple modules at once with Promise.all.

All popular modern bundlers support it and they automatically split dynamically imported modules to a separate bundle. All of the import statements of that module or dependency should be dynamic across your project to work as expected.

## React.lazy

It is also possible to import React components dynamically since React 16.6. `React.lazy` is a function which will handle your dynamic import and make a renderable React component from it. It has one parameter, which is a function returning the import:

```javascript
const MyComponent %3D React.lazy(() %3D> import('./MyComponent'))
```

Module bundlers will handle dynamic imports as `React.lazy` parameter the same as described above.

It is important to know that the component must be the default export of the imported module. If it is not given (e.g. a third party library exports it by name), you can create a module to handle it in your application:

```javascript
export { Component as default } from 'react-library'
```

You can wrap the lazy loaded component by React Suspense with a fallback component. It will render the fallback while the dynamic component is loading.

```jsx
<Suspense fallback%3D{<Loader />}>
	<MyComponent />
</Suspense>
```

## Importing types

Previously TypeScript tried to omit type-only imports from compiled JavaScript code, but it cannot accurately recognized and removed accurately. In some edge cases the import was compiled to your code even if it is only used as a type. They added a new syntax to the language at version 3.8 to prevent this problem:

```javascript
import type { SomeType } from "external-dependency";
```

This way you can use external types confidently without pulling in a new dependency to your main bundle. You can read more about this in the [TypeScript release note](https://devblogs.microsoft.com/typescript/announcing-typescript-3-8-beta/#type-only-imports-exports).

## Real life example

At Sense/Net we are developing a headless CMS called sensenet. One part of our product is the admin-ui that makes content management easy for the customers. It is a complex React application with a lot of internal and external dependencies. Over time our bundle became huge, so we started to optimize it with multiple techniques. One of these is the better usage of lazy loading pages and dependencies.

The biggest improvement was achieved by lazy loading Monaco Editor. It is a code editor which powers Visual Studio Code. It is around 2 MB of parsed JavaScript code and only used on 3 or 4 pages by our application. You definitely don't want to load it for pages where it is not used.

We applied all the above methods to separate its code to a chunk and load it only on-demand. We use it in multiple isolated parts of our application so we had to make these changes for each import of the editor.

An interesting part was the usage of imported functions. We created a new React state which stores the return value of the function. We load and call the function inside a useEffect and show a loader until the state gets a value.

```javascript
export const Loader %3D (props) %3D> {
 const [uri, setUri] %3D useState()

 useEffect(() %3D> {
 ;(async () %3D> {
 const { monaco } %3D await import('react-monaco-editor')
 setUri(monaco.Uri.parse(`sensenet:File`))
 })()
 }, [])

 if (!uri) {
 return <Loader />
 }
 ...
}
```

## Final thoughts

In conclusion, JavaScript and its ecosystem give us a lot of opportunity to improve the performance of our applications. One of the most important aspect of user experience is speed, so it is definitely worth the effort. Hopefully in the future it will be even more easier to achieve such optimization.

If you need help or have any feedback, feel free to comment here.

Thanks for reading my article! If you enjoyed it give a star to [sensenet](https://github.com/SenseNet/sn-client) on GitHub. I hope that you'll [give a try to our headless CMS for free](https://www.sensenet.com/tryit), we are eager to hear your feedback.

In this article we will delve into the dynamic import of JavaScript modules and the lazy loading of React components.

2021-04-07-dynamic-import-recipe-for-a-lightning-fast-application

Dynamic import - recipe for a lightning fast application

## Roots

We launched our new website in October 2020 because we came out with our SaaS model (called sensenet as a service) currently in BETA. This new site with fresh content for the new era allowed us to lead visitors to register to the service. Back then we must to act fast since we wanted to get the whole thing ready for Hactoberfest, for this reason some processes was not detailed enough. Since last year we gathered some stats about the usage and interaction with our site and we thought that some thing can and should be improved.

## Goal

We have some early birds registered to the BETA but we still need more feedback in this phase so our goal is to convince more people to give SNaaS a try. Since this is a much bigger task to fit into a simple 1,5 hours meeting, a [design sprint](https://www.thesprintbook.com/how) seemed as a perfect solution to accomplish this challenge. Our objective was to start from square one and go through the whole process and fine-tune the journey of a customer.

## Process

All of us rescheduled our meetings and cleaned up our agenda to focus only on this task. This was a virtual event (you know why) so everyone joined via [Teams](https://www.microsoft.com/hu-hu/microsoft-teams/free) and worked in [Miro](https://miro.com/) which is perfect for this kind of collaboration. Thanks to our colleague 👏🏼 everything was ready and prepared by the first morning so we just had to join and start working together.


<img src%3D"https://raw.githubusercontent.com/SenseNet/sncom-resources/master/img/posts/miro_guideline.png" alt%3D"miro board overview">


In a design sprint (at least how we did it) there was some special roles. We had a Decider who makes the important decisions (with bigger voting power in each question), and a Facilitator who leads the the whole event.

We went through several phases of collecting ideas in a specific topic, voting and getting closer to our target and by Thursday, we had a prototype to user test on Friday with 5 enthusiastic volunteers👏.

## Results

Feedbacks from the user interviews led us to identify some patterns and from that we were able to create a handful of tasks. We prioritized these and we already see that some of the topics will need additional design sprints and we are looking forward to do so since it's quite effective, inspiring and it changed our daily routine which all can lead to great results.🥳🎈⭐

6 people, 4 days, ∞ coffees and the result is 1 prototype and lot of feedbacks and new ideas by the end of the week. This was our design sprint in a nutshell.

2021-03-24-sncom-design-sprint

A design sprint to fine-tune our website

## 1. Versioning and Approval

Basic building blocks of a collaborative content management process are the different states of content aka. [versions in terms of sensenet](https://docs.sensenet.com/concepts/collaboration/01-versioning). The whole lifecycle of a content from the first draft till the final public version can be tracked using version numbers. Set versioning and approval on a container and your team will be able to follow if a content should be reviewed, corrected or approved both on the admin surface and with the API.


<img src%3D"https://raw.githubusercontent.com/SenseNet/sncom-resources/master/img/posts/collaboration/approval.png" alt%3D"Versioning and approval flow">


## 2. Sharing

With sensenet you can invite your teammates or customers to share content with them, no matter how far they are from you at the moment. Registered users or groups can join you to work on the same content on various levels (view, edit) and you can share link of a content with external users let them, review it or even work together without them having to register. Work together remotely like pros, give your projects a collaborative boost with [content sharing](https://docs.sensenet.com/concepts/collaboration/06-sharing)!


<img src%3D"https://raw.githubusercontent.com/SenseNet/sncom-resources/master/img/posts/collaboration/sharing.png" alt%3D"Sharing">


## 3. Preview comments

[Document preview feature](https://docs.sensenet.com/concepts/document-previews) of sensenet is a useful teamwork tool in itself letting you upload your docs and share them with people who don't have the tools to open them. To make it more powerful we have added the possibility to comment any part of the preview images. This way you could even discuss the design plans with the customer, moving the whole project and all the related content to the same hub.


<img src%3D"https://raw.githubusercontent.com/SenseNet/sncom-resources/master/img/posts/collaboration/docviewer.png" alt%3D"Preview comments">


## 4. Office Online editing

Why would you use different tools for each work phase when you can write, review, discuss and correct docs directly in the browser? [Office Online editing](https://docs.sensenet.com/concepts/collaboration/03-office-online-editing) is integrated to sensenet making it possible to collaborate on documents as you are used to on your own desktop computer or in google docs. 


<img src%3D"https://raw.githubusercontent.com/SenseNet/sncom-resources/master/img/posts/collaboration/office_online.png" alt%3D"Office online editing">


## 5. Notifications

Communication is a key element of good teamwork, everyone needs to know their tasks and where the process is going: we need to give and receive feedback on what affects someone else and what may affect the progress of the project. sensenet, through [webhooks](https://docs.sensenet.com/concepts/webhooks), allows project participants to be notified when and how it is most convenient for them, whether it's an email notification, a slack message, or a trello note.


<img src%3D"https://raw.githubusercontent.com/SenseNet/sncom-resources/master/img/posts/collaboration/notification.gif" alt%3D"Notifications">


## 6. Workspaces

Want to get the most out of teamwork and collaboration? [sensenet workspaces](https://docs.sensenet.com/concepts/collaboration/04-workspace) are made for you. Using workspaces lets you create separate spaces for separate projects with their own content structure, custom permission settings, local teams and roles. Workspaces may contain sub-workspaces, and further sub-workspaces as well, enabling you to create the best solution based on your business needs.


<img src%3D"https://raw.githubusercontent.com/SenseNet/sncom-resources/master/img/posts/collaboration/teamwork.gif" alt%3D"team work">


Okay, that sounds good, but how is it related to a headless CMS? Are these things bounded only to sensenet's admin surface? How can I turn these features to my own advantage, in addition to using the existing user interfaces? Good news, every above mentioned feature is fully available through sensenet's REST API. Yes, you can build your own app using these things as a strong foundation complemented by a customized user interface created by you. Interested to try? [Come and register a free sensenet repository!](https://profile.sensenet.com/?redirectToLogin)

Working on a project in a cross-functional team can be full of pitfalls. I have some tips on how you could use [sensenet](https://profile.sensenet.com/?redirectToLogin) avoiding them and boosting team productivity at the same time.

2021-03-10-6-ways-to-unlock-true-collaboration-with-a-headless-cms

6 ways to unlock true collaboration with a headless cms

We were publishing posts to our blog from time to time but in 2020 we came up with a more strict schedule to regularly post new content about what we are working and what's next.
Now, we have two posts per month published in every two weeks. Since we are working on this as a team, it is important that the document is easily accessible by everyone and a straightforward edit and review process is also a great advantage.

For that purpose we are using GitHub (like the pros). As a non-developer we struggled a bit at the beginning but once we get used to it, this makes our life easier. Every blogpost (like the source code of sensenet) lives on GitHub in a dedicated repository so we can edit them right from the browser, keep track of any changes made and also review and comment it.

When the review is finished and all the proposed changes has been made, the PR gets merged into the master branch. The blog itself is part of our public website powered by [sensenet](https://sensenet.com/tryit) so we needed a tool to sync content from GitHub to the sensenet repo behind sensenet.com.
The process is triggered when a merge is made into the dedicated GitHub repo's master branch then the new post becomes visible on [sensenet.com/blog](https://www.sensenet.com/blog) in all its beauty.

To let everyone know about the new content, we share it on social media ([Twitter](https://twitter.com/sensenet), [Facebook](https://www.facebook.com/sensenetcsp), [LinkedIn](https://www.linkedin.com/company/sense-net-inc)) and post it on [Medium](https://medium.com/sensenet).

Follow us on the channels above and [subscribe to sensenet news](https://sensenet.us11.list-manage.com/subscribe?u%3D4949e56b955d9cfbf5780c04e&id%3Dffe20ccea0) to get the latest updates.

Did you know that this post is born as a markdown file and made it's way to our blog with a help of an automated sync tool? Cool, isn't it!?

2021-02-23-how-we-post

That's how we post

In modern service platforms like sensenet, developers need the possibility to do something when something happens in the service. In more technical terms: handling **events** is one of the most important things we need when building an enterprise application. 

In the old days backend developers would handle this issue by developing a module that runs inside the application when a user uploads a file - but since everything has moved to the cloud, this is not an option anymore. 

Fortunately in a service-oriented environment we can do the same with [webhooks](https://en.wikipedia.org/wiki/Webhook). They are basically **HTTP requests** made by the service and a corresponding handler method on the other side. Developers can then do what their project requires in case of these events - for example archiving a document, starting a build in the cloud or sending a notification email.

Many popular services offer webhooks. You can react for example to [code commits](https://docs.github.com/en/github/extending-github/about-webhooks) on [GitHub](https://github.com) or [email events](https://sendgrid.api-docs.io/v3.0/webhooks/retrieve-event-webhook-settings) in [SendGrid](https://sendgrid.com/). 


<img src%3D"https://raw.githubusercontent.com/SenseNet/sncom-resources/master/img/posts/webhooks/integrations.png" alt%3D"integrations">


In sensenet, webhooks are an easy way to **integrate our service with another**. They are usually triggered by content changes. You can register a webhook for the usual content operations - for example when somebody uploads a file or changes an article.

When such an event occurs, we call the URL you provided. It can be a custom application in your datacenter, a serverless function in the cloud or a 3rd party service like [Slack](https://slack.com/intl/en-hu/) or [Netlify](https://www.netlify.com/). We make these HTTP requests based on the **filter** you define: for example you are interested only in new file uploads in a certain library but not article changes. You also have some control over the request itself - for example you can add custom headers or url parameters required by your webhook handler.

In the future we plan to extend the list of events with other options like permission changes, login events, and so on. Please let us know which events would you like to have a webhook for!

Photo by jesse ramirez and Duy Pham on Unsplash

Webhooks have (finally) arrived to sensenet!

2021-02-10-webhooks

Webhooks in sensenet

At the end of 2020 we sat down to clarify our goals for the next year (both on company and team level) and defined the way to reach them. We came up with the idea to use OKR for that so we started to get familiar with the methodology and defined objectives and key results for Q1.

## OKR in a tiny nutshell

"Objectives and Key Results (OKR) is a critical thinking framework and goal setting methodology that helps companies to align goals and ensure everyone is working collaboratively on goals that really matter." (source: [weekdone.com](https://weekdone.com))

We found that [Weekdone](https://weekdone.com/) offers everything we need at the moment to start our journey so we decided to give it a go. Since every department has a role in reaching the goals, we applied the methodology to the whole company.

## Journey so far

We organized a kick-off meeting to define high-level goals then every team specified lower level objectives and key results. Fortunately right after defining these objectives, we started to implement new processes in our day to day work, so for january 2021 we had some practice in this new framework and we got used to monitor the results every week.


<img src%3D"https://raw.githubusercontent.com/SenseNet/sncom-resources/master/img/posts/minivan.jpg" alt%3D"mini van">


## Plans for Q1

We've set some goals based on the results of last year that we should reach by the end of Q1. These goals include increasing website traffic (more visitors, lower bounce rate) and getting more followers and engagement on social channels. All of these help us promote our new product (SNaaS) and bring new users to the platform. We have defined the target number of new customer repositories by the end of Q1 and the required steps to reach this.

With the help of a marketing agency, we've come out with a content strategy for the whole campaign which we will follow to reach our goals in the first quarter of 2021. This includes regular posts to different social media channels, blog posts, paid ads, newsletter and so on. We will of course monitor the results throughout the whole quarter and make adjustments if needed.

### Product

Along with sales and marketing strategy, we will keep improving the product itself and optimize our internal processes.
We'll look for possible steps that could be automated like repo registration and email notifications. Right now, the whole process is done manually which is manageable for now but we hope that shortly we will have more and more registrations and repo requests which cannot and shouldn't be handled manually.


<img src%3D"https://raw.githubusercontent.com/SenseNet/sncom-resources/master/img/posts/plane_engine.jpg" alt%3D"plane engine">


We constatly look for opportunities to make user experience better so we plan to introduce other payment methods for business and enterprise plan customers (don't worry, [developer plan](https://www.sensenet.com/pricing) stays free).

Along with the product, documentation was improved a lot during the last year, but this is something that you have to constantly improve to make onboarding and development easier. We need to keep existing docs up to date and discover missing parts then write them.

As an essential part of the ecosystem, we are implementing in-house monitoring tools to be able to see what's happening with the repos and the whole service. With that, we can keep an eye on the usage of the service and infrastructure (so we can scale it up if needed) and also filter inactive repositories in order to contact repo owners and help them with the next steps.

## What's next

The plan we have is much larger than what we can do in a single quarter so as we get closer to the end of Q1, we will start defining goals for the next quarter based on the big picture we have in our mind for the product and for the company. Of course it's important to check last quarter results and adjust our goals quarter by quarter.

In the followings we will get back with more experiences and stats to share.

As the holiday season ended, we have quite much to do at the beginning of the year to launch SNaaS according to our plan. Get a short insight what we have in mind for Q1.

2021-01-27-2021-kick-off

2021 kick-off

The basic purpose of code refactoring is to make the code more efficient and maintainable. Of course we are about to keep our code up-to-date and optimize its performance so we thought that it is time to clean a lot of complicated lines of code in the document viewer. ♻️

## Logic ✏️✂️🚀🐛👭

The main goal was to simplify the code. There were some magic numbers, unnecessary props, useEffects that run many times, so we had to go deep to rethink the logic. After planning, we had to rebuild functions based on the existing code. Although we try to avoid code repetition, sometimes it is even necessary to break down existing logic according to its function. As a result, Thumbnails and PageList became two separate components, for example. ✏️

Not only the code has become simpler but also some of the features. For example, rotating pages is only a form of visual representation, so it is unnecessary to store this information, it can be reproduced anytime. SearchBar widget become redundant too, because all browsers can search on page, so we removed this from selectable widgets. ✂️

We've put a great emphasis on improving performance as well. Sometimes we can achieve significant results by making small changes, such as taking advantage of the opportunities provided by our framework: replacing useEffect with [useMemo](https://reactjs.org/docs/hooks-reference.html#usememo). 🚀

Finding and fixing bugs in the software is also important in case of a full review like this. Of course, during the re-rolling of this function, we also encountered many cases where a different solution had to be applied than we originally planned. 🐛

The point is that we tried to look at the possibilities from the user's point of view and we were trying to make this feature user friendly.👭

## Style 🎨

We will release another new option to users, which is overwriting styles from a higher level. It is very important to enable users to shape our solution for their own needs. So far there have been relatively few opportunities for it, but we are changing that now:

You can define your style on your own and you can pass it to the component itself, like:

```javascript
const useDisabledStyle %3D makeStyles(() %3D>
 createStyles({
 iconButton: {
 "&:disabled": {
 opacity: 0.26,
 },
 },
 })
);

const disabledStyle %3D useDisabledStyle();
```

If you use typescript you can also see the possible classes what you can overwrite:


<img src%3D"https://raw.githubusercontent.com/SenseNet/sncom-resources/master/img/posts/docviewer/overwrite_styles.png" alt%3D"overwrite styles">


Since our designer always come up with new solutions and the style is constantly changing, we can never consider it done. 🎡

## New features 🎉

For those who have been using sensenet for a long time, it may not be new, but if you have just joined, you may come across the keywords redaction, highlight and annotation for the first time.

**Redaction** 🔳

Sometimes when you are working with sensitive information 🗝️ in documents you don’t want to share them with everyone, only users having the appropriate privileges. What if you would like to share the document except the sensitive information? This is the case when you need to apply redaction.
With this feature you can hide parts of your doc with a black rectangles. Opening a document without redaction is only possible if the user has permission for it, otherwise the page will be full with black squares. 🙈


<img src%3D"https://raw.githubusercontent.com/SenseNet/sncom-resources/master/img/posts/docviewer/redaction.gif" alt%3D"redaction">


**Highlight** ⭐

The purpose of highlighting is to draw attention to important information in a text. 📑


<img src%3D"https://raw.githubusercontent.com/SenseNet/sncom-resources/master/img/posts/docviewer/highlight.gif" alt%3D"highlight">


**Annotation** 💬

Annotation is extra information associated with a particular point in a document. It can be a note that includes a comment, explanation or anything what you would like to share with the audience in a designated place in the text. 📋


<img src%3D"https://raw.githubusercontent.com/SenseNet/sncom-resources/master/img/posts/docviewer/annotation.gif" alt%3D"annotation">


**Usage**

The operation of these three shapes is basically the same with some small differences:
- you can create them with a click-move-click method (check gifs) ✏️
- you can delete them with `backspace` or `delete` keys (except annotations) and also with a `right-click` on the shape then choosing delete button on the popout. 🚮
- you can also drag and drop the shapes if you would like to move them to another position on the page. ↖️↘️
- right-clicking on shapes opens different popups. For the redactions and highlights only a delete button appears, but for annotations, a toolkit with different configuration options 🔧 shows up where you can set line height, font size, font color and make your text **bold** or _italic_.


<img src%3D"https://raw.githubusercontent.com/SenseNet/sncom-resources/master/img/posts/docviewer/right-click.png" alt%3D"right click">


## What's next 📅

In the upcoming releases we will make these updates public, don't forget to check out the [changelog](https://www.sensenet.com/frontend-updates)!

See you in SNaaS! 🚀🎉

🌇 “Cities grow, cities evolve, cities have parts that simply die while other parts flourish; each city has to be renewed in order to meet the needs of its populace…” 🌆 -Grady Booch

2021-01-13-docviewer-updates

Document Viewer updates

At sensenet, we are working on making the product and our services better with fixes, improvements and new features every day. Since we wanted to provide a predictable and reliable service in addition to being constantly updated and improved we had to work out a process to make the updates fairly frequent and seamless yet valuable. The following article details our delivery system.

## Different skill sets, one common goal

sensenet is designed and developed by a cross-functional team, which means we have to manage and improve multiple code bases developed with different kind of technologies and frameworks. Since sensenet is open-source, most of the source code from the core layer to client packages is shared publicly on [GitHub](https://github.com/SenseNet). Beside source code our text resources (docs and even this blog post) are stored and shared on GitHub as well keeping our work and the whole process open and transparent.

## Bug's life

We're using GitHub not only for versioning and publishing the product source code and the documentation, but also for supporting our teamwork and transparency of our processes toward the customers and the community. Our team is working in a scrumish way along sprints, milestones, releases, epics and issues, and taking advantages of GitHub and [ZenHub](https://www.zenhub.com/) we can share everything with you. The product roadmap, the team backlog and everything we're working on is available, so you can not only follow but also influence the product development process. A bug's lifecycle from detecting it till publishing the fix to the production environment can be easily followed. 


<img src%3D"https://raw.githubusercontent.com/SenseNet/sncom-resources/master/img/posts/bug.jpg" alt%3D"bug">


## Review and test

Before customers get the fixes and the new features the changes are checked several times on multiple environments. During development automated daily builds provide the possibility of internal testing in staging and pre-production environments. This way we can be sure that when we get to the release all the pieces are working together as they should.

New things are not only reviewed by multiple developers but also tested with automated unit and integration tests and they can only be merged when all the checks were successful. After that the change gets to another test phase which means it becomes published to our test environments. If a change proves reliable during the test phase, it will be included in the next release. We have multiple isolated environments for all the phases (development, test, demo, etc.). In the next section you can see how and when they are updated.

## Releases and the patch day

We publish new releases in every four weeks. Since we have to create new packages for multiple platforms and multiple services at once, we decided to go along with this regularity, because for now it serves product development and customers the best. This way we can be sure that things we release from our hands work well both for SNaaS customers and for the open source community.

We update the production environments (customer repositories, central system, etc.) in every fourth monday, which means it is easy to plan with both fixes and new features. We always share detailed change logs per packages/components, so you can be sure you won’t miss anything.

[Backend updates](https://www.sensenet.com/backend-updates) ⚙

[Frontend updates](https://www.sensenet.com/frontend-updates) 💅

## Everything is isolated

Operating cloud-base content management services requires high-quality security regulations and standards. These thing are extremely important for us too. Individual repositories are totally isolated, which means both database and service layer are separated per repository. This way we can meet today's standards in data security, isolation, scalability and backup, giving us the advantages in terms of security issues and updates.


<img src%3D"https://raw.githubusercontent.com/SenseNet/sncom-resources/master/img/posts/separation.jpg" alt%3D"separation">


## What's next

Next year will mostly be about optimizing and automating release, install and deployment processes. So there is still a long way to perfection, but the path is clear. Come and join us in our journey, [request a free sensenet repository](https://profile.sensenet.com/?redirectToLogin), try the most flexible and versatile headless CMS!

See you in SNaaS! 🚀🎉

We are constantly working on new features, fixes and other awesomeness. Let’s see how these new things get to customers.

2020-12-15-insight-to-snaas-delivery-process

Insight to SNaaS delivery process

This year was dedicated to SNaaS launch preparation which has generated various tasks in different fields like marketing, sales and development. Fortunately we were mostly able to stick to our plans defined at the beginning of the year.
Below, you can see our timeline for 2020 with the important milestones and happenings.

## Q1 The plan
At the first quarter we started to define tasks and goals for the whole year. By the end of Q1 only one thing was sure: we wanted to launch SNaaS in BETA along with Hacktoberfest. This meant we had to have our new website up and running with fresh new content to promote the new service.
We hired a professional marketing agency to help us with the content creation. In addition to the website revamp, we entrusted them to get new users for SNaaS. This part will happen in 2021, once we end BETA phase and launch the service.

## Q2 Struggle

<img src%3D"https://raw.githubusercontent.com/SenseNet/sncom-resources/master/img/posts/2020_sumup_STRUGGLE.jpg" alt%3D"struggle">


This quarter was quite busy since we needed to work on many different areas at the same time.

To understand the processes and the tasks we should work on, lot of customer journeys have been drawn.
We defined that we require (to mention a few):
- profile page where users manage their account and subscriptions
- surface to manage under the hood processes in-house (e.g: repository creation, account management, invoicing)
- email templates

Of course every step led to new questions and additional tasks.🥳

In the meantime our awesome DevOps guy worked really hard in the background to figure out how sensenet could become a containerized application and planned the whole infrastructure along with the System Engineers.

Concerning the new website we discussed a lot with the marketing agency to help them understand sensenet and the target audience of the new service. During this period we lived mostly in Microsoft Wor(l)d polishing our communication.

## Q3 Ready?
We needed a website design so we created one. Of course it came with a lof of modifications hundreds of versions and some user tests.

By the middle of september the new website gone live but we weren't nearly ready for Hacktoberfest.
We also needed some (at least 60) new Hacktoberfest tagged tasks, a dedicated website and in-house testing of every step of the new service (from registration to content management)

## Q4 Whew..
After Hacktoberfest which - was less hyped this year than we thought - we started to work on automations and other optimization tasks.

During the event we collected what we could automate from our processes and currently we are implementing these steps.
We also looked into analytics and hotjar results to find the weak points of the new site so we constantly improving user experience based on these infos.

Since we want to launch a marketing campaign early next year, we started the preparation in the form of daily social media posts and monthly blogposts.

This is pretty new to us so we need some time to get used to this activity. Great that we started this in time.😊

## 2021 - A new beginning

<img src%3D"https://raw.githubusercontent.com/SenseNet/sncom-resources/master/img/posts/2020_sumup_NEW_BEGINNING.jpg" alt%3D"new beginning">


Next year we can reap the fruit of our hard work since we're going to launch SNaaS in Q1 but before that we need to heck some boxes like API and penetration tests, finalize our live infrastructure and get everything ready for the marketing campaign.

See you next year!🎄🎉

2020 was a looooong and productive year for us. A lot of things happened with one common goal: launch sensenet as a service (or SNaaS for short).

2020-12-08-2020-sum-up

2020 sum-up

If you followed us, you could have read it a million times already, we are about to launch sensenet in SaaS model - which is a huge change from selling a traditional (E)CMS - to serve our customers with a cloud-based, headless CMS. These changes not only affected our sales and development processes but also our communication and at the same time it made necessary to update our public website. Easiest thing ever, since the product we develop is perfect for creating public websites (among many other things). The old website was built with the previous version of the product which was a complex ECMS, so the time was perfect not only to redesign the site and update every content, but to test the new model in this specific scenario.

## One repository to rulem them all

The public website is one of the main pillars of a company's communication and must convey the same clear message along with all the other channels. Technically it means you have to create and maintain tons of content day to day, collaborate on them with the other editors and publish them on multiple platforms on different devices. Content makes the world go 'round, but fortunately in sensenet everything is a content and being a real content-based solution for every business problems, it offers the perfect mixture for projects that are about sharing information.

The long and the short of it is that we started the project with content, working out the model and the structure. This step is the core of such projects and it is seamless with sensenet content types. Taking advantage of type inheritance and the endless possibilities of expanding and combining these types we could freely shape the content model till it fitted our needs.

## Collaboration + security %3D faster development

At the launch we had 25+ custom content types and 500+ contents and they were created not only to vary metadata (fields) but also for handling security issues. Thanks to the tree-based content structure we could separate content branches for developers and editors based on their different permission levels. This way they could work simultaneously on the project without disrupting each other’s work.

As for any company, collaborative work is a key for us and by using a content-based solution to this website revamp project we also learn how fast we can work together. As the model and the structure was ready, both content editors and developers could start working on their part: editors produced the content, developers set up and built the single page application using sensenet's super-flexible REST API.


<img src%3D"https://raw.githubusercontent.com/SenseNet/sncom-resources/master/img/posts/rte.png" alt%3D"rich text editor">


## One content, multiple platforms

Want to multiply the number of readers of your content without the headache of multiply them per platform and device? Use a headless CMS, use sensenet! 😊 We've built up both desktop and mobile version of our website, our blog and even our in-house administration system on contents (articles, files, blog posts) shared across these solutions without having to multiply them. An endless wealth of possibilities, isn't it? If we figure out someday, that we want a mobile app, we can build it upon the same repository, with the same contents using the same API.


<img src%3D"https://raw.githubusercontent.com/SenseNet/sncom-resources/master/img/posts/sncom-mockup.png" alt%3D"mockup">


## SNaaS for the future

Our previous website - made with the old product - was built using a lot of old technologies both server and client-side. These technologies were decent and modern back in the day, but as time goes on, every technology, framework and library gets older, loses its support and makes old projects unsustainable. If we stick to traditional CMS' then this usually means that the project needs to be rebuilt from scratch from content to user interface. We have run into this problem many times, but we won’t any more. sensenet as a headless CMS gives us the freedom of changing the ui, adding new features or integrate it with anything without having to touch the repository and the backend. sensenet's REST API is future-proof and while we hope that [Next.js](https://nextjs.org/) (chosen as the basis for our website) will stay supported and popular for a long time, we only have to replace the UI if the time comes.

## Sum up: Why we chose sensenet? (and not because it is our solution🙂)

- **short deadline**: the whole project (including UX and UI designing phase) had to be completed in a month and a half,
- **productivity**: developers and content editors could work simultaneously
- **multi-platform**: a content should be created only once, but can be published in multiple forms
- **gentle learning curve**: developers can choose their preferred technology to connect with sensenet
- **no technical know-how for the editors**: they only have to use a WYSIWYG editor on the admin surface
- **permissions for users in different roles**: editors and developers can access only the appropriate content branches
- **flexible type system**: content can be supplemented with various types of metadata

Eat your own dogfood they said. It'll be fun they said...

2020-11-30-using-your-own-product-a-headless-cms-case-study

Using your own product - a headless CMS case study

sensenet joined #Hacktoberfest celebration for the second time. This year, learned from our experiences back in 2019, we prepared a lot and created a dedicated site and much more to help open source contributors around the world🌍.

This was a special year for us since we launched 🚀, along with Hacktoberfest, our new software as a service product (called SNaaS).

In the first week we had many registrations and contributors started to work on the dedicated issues. In the coming weeks the buzz chilled down, mainly because of stricter event rules and because of the fact that this year we wanted real contributions in the form of end-to-end tests written in cypress.
Now, let's see the exact numbers.

## Stats

**resolved issues: 20**

**winners: 13** (special thanks for those who resolved more than one issue)

Since we launched SNaaS in BETA along with Hacktoberfest, as part of the challenge, contributors had to register to the service and claim a free repository. During October we had 36 new repo registrations altogether. These repositories can be used in the future as part of our developer plan or upgraded if your project requires so ([check our plans](https://www.sensenet.com/pricing)).

## Swag

This year we made limited edition super socks 🧦 (not the usual t-shirt) for the winners and a 10% coupon for SNaaS business plan.
We contacted all the winners with further details, the production will start in the next few weeks and you will get your swag as soon as possible.

## See you next year

Again, thanks for all the contributors🙏. Keep using your repositories and feel free to give us feedback, our ears are wide open. (:

Sign up for our [newsletter](http://eepurl.com/gbh42T), where you will not only receive the latest sensenet product news, but also be the first to know about our Hacktoberfest **2021 celebration** and other community related giveaways.

Hacktoberfest 2020 is over, thanks for all the contributors. Check this year's stats and results.

2020-11-11-hacktoberfest-sum-up

Hacktoberfest 2020 sum-up

In early summer when it became clear that we want to launch the new SNaaS in October we also decided to redesign our website as well. Given that it was our goal to finish the site in September so we can properly promote our product and make a site that gives easy to access information about it. The schedule was very tight but at the end of the day the team made it happened. 

## The research 

This time I didn’t had to do the research alone because Blackhole Media (a marketing agency) helped us out in the process. They did the personas and competitive research and we had sessions and small workshops together where we made customer journey maps and the sitemap as well. Because of the recent pandemic situation in the beginning we did everything online and used Miro during our sessions where everyone could brainstorm and share his or her ideas at the same time. 

Later, we had the chance to work together in person as well, but we kept using Miro throughout the whole design process. 


<img src%3D"https://raw.githubusercontent.com/SenseNet/sncom-resources/master/img/posts/miro-board.png" alt%3D"miro board">


## Wireframing 

After the research when everyone agreed on what info should go where and made the sitemap it was time for me to start making the low-fidelity wireframes. I used Adobe XD as my primary design tool. As the first step I made the wireframe as we agreed on the sitemap but after I finished it and showed to the team and the stakeholders as well, we made a few small changes to the wireframe. 

During the design of the low-fidelity wireframes the sales team and Blackhole Media were working tirelessly on the copy of the website so by the time I finished, and everyone agreed on the first iteration they could be ready as well. 

The next step from here was the high-fidelity wireframe with the finished copy and this time I made a clickable prototype as well. I choose to do a first round of user testing after I got finished with the high-fidelity wireframe because we wanted to make sure that if there’s any issue with the design we should find out as soon as possible and make it right in the early stages. 


<img src%3D"https://raw.githubusercontent.com/SenseNet/sncom-resources/master/img/posts/low-fidelity-wireframe.png" alt%3D"low fidelity wireframe">


## User testing 

After I was done with the clickable prototype it was time to recruit participants for the user testing. We managed to recruit seven people and arranged the test times. Because I was out of office during the time of the tests, I did a workshop with our sales team where they learned how to conduct the user tests. By the time I got back they finished with everything, so I was able to watch the recordings and read the notes they took. Fortunately, I had to do only minor changes, after that I started to work on the final design. 

## Final design 

For the final design the team choose the colors and photos that we will be using. I started laying out everything and made it into the design. At this point I haven’t changed anything in the layout as it was validated with the user tests, so I was able to focus only on the design elements and chose which images should we use. After everything was in place it was time for another round of user validation which went very smoothly. 

## Conclusion 

I had a lot of fun during this project although it had a very tight schedule, we made it working thanks to all the people who participated and helped to make it happen. 

You can check the site at [sensenet.com](https://sensenet.com)

As lot of you already know we came out with the SNaaS (sensenet as a service) beta for the hacktoberfest and with the whole new admin system it’s only fair that we would do a whole new website for sensenet.com as well from scratch.

2020-10-19-redesigning-the-sensenetcom-website

Redesigning the sensenet.com website 

As you may know the open-source community celebrates #hacktoberfest this month. **sensenet** also participates in this event by proposing limited edition socks as a reward for solving #hacktoberfest labeled issues on a dedicated [GitHub board](https://github.com/orgs/SenseNet/projects/7).

To complete the challenge you have to register a free sensenet repository ([see more details here](https://hacktoberfest.sensenet.com/#eventDetails)) and choose an issue from the [board](https://github.com/orgs/SenseNet/projects/7).
 
So far we have twentyish repo registration (which is quite good) but the progress on the [hacktoberfest board](https://github.com/orgs/SenseNet/projects/7) could be better.

## So what kind of issues we prepared for this year's celebration?


<img alt%3D"github board" src%3D"https://raw.githubusercontent.com/SenseNet/sncom-resources/master/img/posts/github_board.png">


Basically you have to write end to end tests in JavaScript for different test cases like breadcrumb feature or document viewer (you can see the full list on the dedicated [GitHub board](https://github.com/orgs/SenseNet/projects/7)).
For end-to-end tests we use [Cypress](https://www.cypress.io/) (an all-in-one testing framework) which makes setting up, writing, running and debugging tests easy. To learn more about Cypress visit their [documentation site](https://docs.cypress.io/guides/overview/why-cypress.html#In-a-nutshell).

We are also here to help, so if you're stuck, drop us a message on [Gitter](https://gitter.im/SenseNet/SNaaS) or comment on the issue in question.

Your efforts will be rewarded by a limited-edition sensenet hacktoberfest socks. We can share a sneak peek from the work in progress and we will share the final design very soon so stay tuned.

<img alt%3D"super swag" src%3D"https://raw.githubusercontent.com/SenseNet/sncom-resources/master/img/posts/super-swag.jpg">


Come [celebrate with us](https://hacktoberfest.sensenet.com), improve your JS skills and earn your super swag!

Join our celebration and improve your JS skills and earn your super swag easily! Write end-to-end tests using Cypress for different use cases.

2020-10-13-hacktoberfest-2020-updates

Hacktoberfest update!

This year we are much more prepared compared to 2019 last minute Hacktoberfest participation. We started brainstorming months ago, thanks to that we now have a [dedicated website](https://hacktoberfest.sensenet.com) for the event with all the required information to help you contribute and get your sensenet super swag! 

Along with Hacktoberfest we also launch our new cloud-based model, [sensenet as a service (SNaaS)](https://docs.sensenet.com/concepts/introduction/04-what-is-snaas) in BETA 🚀. Your task will be to write small tests for the admin ui of SNaaS repositories, making the whole experience even more reliable for everyone. To start, you’ll have your own repository to work with during Hacktoberfest (and you can keep using it after the event 😉 ) 

If you participate in our Hacktoberfest event, you are lucky ‘cause you can have more storage, users and content for free till the end of 2020. Aaaaaand… you’ll also get 10% off from your subscription from January 2021! 

Of course that’s not all. We also have some super swag for this year’s celebration. If you have some really old socks 🧦, this is a great time to replace them with our limited edition Hacktoberfest socks (more details later). You need to hurry since we only have 60 pairs. 

Since this is a special event (Hacktoberfest along with BETA launch) we need your feedback more than ever to help us make the service as good as possible for you and everyone else (we'll give more info about this dedicated channel later).

So there’s nothing left but to [visit our site to jump in](https://hacktoberfest.sensenet.com)!

This is the second time Sense/Net participates in Hacktoberfest event to encourage developers to familiarize with our product and get in touch with the community.

2020-10-01-hacktoberfest-is-back

Hacktoberfest is back!

In the IT world you often handle sensitive data, which you don't want to share with the whole universe. But how you can hide those contents from outsiders? What if you would like to share those things only with a specific group of users? Or other data with another group? 

Of course there is a common solution for that: permission system. Almost every software has permissions which handle what users can see or do.

I think most of us use some kind of social media. Think about searching for someone and that by default you cannot see her/his photos, but after you apply a friend request everything changes.
And what about your company data? Unless you are the boss, I am sure that your company has data for which you do not have sufficient permissions.

Permissions are everywhere. And of course sensenet has its own permission system as well. On the new admin surface 
handling permissions was only possible with coding and running commands. Till now. 🕛 In the last couple of weeks we were about to design and implement the simplest, easiest to use **permission editor**.

## Customize it as you want 🔧🔨

sensenet has a lot of built-in permissions but there are some reserved ones that you are free to use in case you have special needs ([custom permissions](https://docs.sensenet.com/concepts/user-and-permission-management/04-custom-roles-and-permissions#permissions)). You can also group these permissions for the permission editor. The related settings file is available under Setup menu / Permission.settings.

The default settings are the following:

```{
 "groups":[
 {
 "Read":["See", "Preview", "PreviewWithoutWatermark", "PreviewWithoutRedaction", "Open"]
 },
 {
 "Write":[ "Save", "AddNew", "Delete"]
 },
 {
 "Versioning":["OpenMinor", "Publish", "ForceCheckin", "Approve", "RecallOldVersion"]
 },
 {
 "Advanced":["SeePermissions", "SetPermissions", "RunApplication"]
 }
 ]
}
```

On the permission editor dialog you can see the groups and permissions based on these settings. 


<img src%3D"https://raw.githubusercontent.com/SenseNet/sncom-resources/master/img/posts/permission_groups.png" alt%3D"permission groups">


## How to use it? 🎮

Select a content from your repository, right-click on it and select 'Set permissions' from the dropdown. On the permission view you can check the permission entries (users or groups) which are inherited or set directly on the current content. Selecting an entry opens the permission editor dialog.

On the dialog use the switches to enable/disable a permission. There are also group level switches, so you can easily enable/disable all the permissions in the selected group...and there is the king of kings: Full access 👑 with which you can turn all permissions on/off.

When you open the dialog some permissions are disabled because they are inherited from a parent and you cannot override them. 
Changes only apply on clicking Submit button so for your comfort there is also a reset button to restore the unsaved changes.


<img src%3D"https://raw.githubusercontent.com/SenseNet/sncom-resources/master/img/posts/permission_how_to_use.gif" alt%3D"how to use permissions">


## Additional features 💄👓👜

**Make content public/private**

If you would like to share your content (content can be almost anything, cause in sensenet everything is a content) with visitors who are not users in your repository you can do it easily by clicking on "Make content public" button. If you change your mind reverting this is easy as it was to set. This thing come in handy when you build a public website and most of your repository data is shared with all the visitors.


<img src%3D"https://raw.githubusercontent.com/SenseNet/sncom-resources/master/img/posts/permission_make_public.gif" alt%3D"make a content public">


**Assign new permission**

If you would like to grant permission for someone on a content who has no permission setting at all, you can do it using the _Assign new permission_ button. Search for and select the user or group to whom you want to set permissions and turn on/off the switches. 😉


<img src%3D"https://raw.githubusercontent.com/SenseNet/sncom-resources/master/img/posts/permission_assign_new.gif" alt%3D"assign new permission">


**Local only**

One of the big advantages of sensenet content repository tree is inheritance which is applied on permissions as well. However, there are cases when you do not want child contents to inherit permissions. For example you want to allow certain users to see a content (e.g. a Content List) but you do not want them to be able to see contents that are inside this container. To avoid permission inheritance, mark permission entries as 'local-only'.
On the permission view these local-only entries are marked with an icon.


<img src%3D"https://raw.githubusercontent.com/SenseNet/sncom-resources/master/img/posts/permission_local_only.gif" alt%3D"local only permissions">



**Force relations**

Some of the built-in permissions requires to allow other permission(s). E.g: If you would like to set Preview permission to an entry it requires to have See permission as well. You don't need to handle these relations cause it is automatic in the background. Setting the Preview permission will set See permission as well.


<img src%3D"https://raw.githubusercontent.com/SenseNet/sncom-resources/master/img/posts/permission_force_relations.gif" alt%3D"force relations">



## Must read 📚🔖

More details about sensenet permission system:

[Document level Permissions](https://docs.sensenet.com/concepts/user-and-permission-management/02-document-level-permissions)

[Role based Permissions](https://docs.sensenet.com/concepts/user-and-permission-management/03-role-based-permissions)

[Custom Roles and Permissions](https://docs.sensenet.com/concepts/user-and-permission-management/04-custom-roles-and-permissions)

Nobody can hurt me without my permission. /Mahatma Gandhi/

2020-09-21-permission-editor

Permission editor on the admin ui

The product is intended mainly for developers, so the time has come to serve this main target group not only with the software but also with sufficient and quality content.

# Previously on sensenet docs

Our old documentation was made when sensenet was a completely different software. As an ECMS it had multiple layers not only for different types of developers but also for end-users and system operators. Since now sensenet is a headless solution most of the documentation target groups are gone, so the old structure was no longer sustainable. *wiki.sensenet.com* was built with [MediaWiki](https://www.mediawiki.org/wiki/MediaWiki) that was ok for the old software but as we were moved to GitHub with sensenet we wanted to make the docs open source and community driven as well, which made the old solution difficult to maintain.

We've decided to create a new community site generated by [Jekyll](https://jekyllrb.com/) which serves the documentation, the blog and other community related needs. It seemed to be a good idea till we reached the number of docs where it became unusable and unmaintainable. So, we came to a turning point where we had to rethink everything that we thought about developer docs and ask the community for help.

Hacktoberfest 2019 was a good opportunity to reach fellow developers who were already somehow connected with sensenet. We've created a survey with various question about what they are expecting from a developer documentation. We were curious about the ideal length, structure and type of docs, we were surveyed the user habits, needs and wants. The results made clear how we should structure and prioritize the work on the new docs: the most important is to create a ton of tutorials, make the concepts clear both for developers and non-dev decision makers and add a well-structured and complete API reference.


<img alt%3D"Survey results" src%3D"https://raw.githubusercontent.com/SenseNet/sncom-resources/master/img/posts/docs/survey.png">



Well, I'm happy to announce that the [new documentation site](https://docs.sensenet.com) is up and running. Not all the docs are ready yet but we're quite happy with the work we've done with the concept and API docs and of course we're never stop improving and expand the docs based on the audience's needs: we're constantly working on end-user docs for the admin-ui and trying to create as much tutorials as it is needed to present that using sensenet is super easy and effective.


<img alt%3D"docs.sensenet.com mainpage" src%3D"https://raw.githubusercontent.com/SenseNet/sncom-resources/master/img/posts/docs/mainpage.png">


# Keeping it fresh 

Okay, the site is ready, and the new docs will coming constantly. But how can we keep the momentum? Our product team is now quite small and improving a product is usually more important than working on the docs. So, we decided to choose a dedicate day when we are all working only on the docs. Aaaaand *Kontent Kedd* ('kedd' is tuesday in hungarian) was born! Every other week on tuesday the whole team is working to make the documentation better and better. 💚

# Open, fast and searchable

As I mentioned above keeping the docs on the community site was problematic in several ways. We had to choose a future-proof solution that makes possible to come up with an open, community driven, well-structured and easy-to-use documentation page. The code base of sensenet is on GitHub since ages so as the community site and we did not want to change that for the [new docs](https://github.com/SenseNet/docs.sensenet.com) either. To generate the actual site our choice fell on [Gatsby](https://www.gatsbyjs.org/) which not only indicated that we became familiar with a technology that was completely new for us, but it also generated some possible future tasks like creating a Gatsby source plugin for sensenet or improving our OData requests for collection of binaries.

While you are discovering a new technology and its documentation effective searching is the key and so was as for as while we were developing the new site. In addition to quick search the docs are grouped and ordered in a way that helps you learn new things step-by-step. The docs are organized in multiple levels which makes the connections easier to understand and all the docs have a 'pager' with which you can navigate back to the previous or forth to the next topic.


<img alt%3D"search in docs.sensenet.com" src%3D"https://raw.githubusercontent.com/SenseNet/sncom-resources/master/img/posts/docs/search.gif">


The top-level menus are completely designed by the above-mentioned surveys results. *Concepts* containing sensenet basics not only for developers. *Tutorials* and *Example Apps* help you start with sensenet offering you source code as step by step guides and downloadable GitHub projects. *Admin-ui Guides* is a place for useful manuals for the admin surface. In the *Integrations* menu you would reach the demonstration of current integrations and some help on how to integrate sensenet with anything. Last, but not least at the *API Docs* you can find collection of references, code snippets and examples in sort everything you need to complete a project.


<img alt%3D"docs.sensenet.com API Docs" src%3D"https://raw.githubusercontent.com/SenseNet/sncom-resources/master/img/posts/docs/api-docs.png">


Just like the software, its documentation is open and stored on GitHub. Any suggestion, question and contribution is welcome, if you have any feedback for us, we will be happy to hear it on [GitHub](https://github.com/SenseNet/docs.sensenet.com) or via [chat](https://gitter.im/SenseNet/sensenet).

As we started working on SNaaS it became clear pretty soon, that the developer documentation needs radical changes both structurally and in appearance.

2020-07-15-modernizing-sensenet-docs

Rebirth of sensenet docs

## What is IdentityServer4?

IdentityServer4 is an OpenID Connect and OAuth 2.0 framework for ASP.NET Core 3.0. Come again? What does that even mean? What is OpenID Connect and OAuth 2.0? 

Quoting from [https://oauth.net/2/](https://oauth.net/2/)
> OAuth 2.0 is the industry-standard protocol for authorization. OAuth 2.0 focuses on client developer simplicity while providing specific authorization flows for web applications, desktop applications, mobile phones, and living room devices. This specification and its extensions are being developed within the [IETF OAuth Working Group](https://www.ietf.org/mailman/listinfo/oauth).

Quoting from [https://openid.net/connect/](https://openid.net/connect/)
> OpenID Connect 1.0 is a simple identity layer on top of the OAuth 2.0 protocol. It allows Clients to verify the identity of the End-User based on the authentication performed by an Authorization Server, as well as to obtain basic profile information about the End-User in an interoperable and REST-like manner.

Ok, so IdentityServer4 is implementing the industry-standard protocol for authorization. That sounds awesome. We don't have to implement hacky/non-standard ways to implement authorization, IdentityServer4 does most of the work for us.

## How can I authenticate to sensenet from a SPA then?

The easiest way is to use our newly created React component library for handling authentication through a provider ([@sensenet/authentication-oidc-react](https://www.npmjs.com/package/@sensenet/authentication-oidc-react)). It uses [oidc-client](https://www.npmjs.com/package/oidc-client) under the hood. If you are using another framework or just vanilla js, this lib is your best bet.

- Add @sensenet/authentication-oidc-react to your react app either with `yarn add @sensenet/authentication-oidc-react` or with `npm install @sensenet/authentication-oidc-react`
- Add a configuration file like this:

```typescript
import { UserManagerSettings } from '@sensenet/authentication-oidc-react'

export const repositoryUrl %3D 'https://my-service.sensenet.com/' // This is the repository you want to log in to

export const configuration: UserManagerSettings %3D {
 automaticSilentRenew: true, // Access tokens only valid for a period of time with this set to true it will be renewed 1 minute before expiration
 client_id: '', //clientId of your repository
 redirect_uri: `${window.location.origin}/authentication/callback`, // This is the url it will return with the access token
 response_type: 'code', // This value tells OAuth2 what should be in the response, we want the access token
 post_logout_redirect_uri: `${window.location.origin}/`, // This is the url the server will redirect after logout
 scope: 'openid profile sensenet', // The scopes we want access to, don't forget to add sensenet!
 authority: 'https://is.test.sensenet.com/', // The identity server that will talk with our repository
 silent_redirect_uri: `${window.location.origin}/authentication/silent_callback`, // This url is going to be called for silent login
 extraQueryParams: { snrepo: repositoryUrl }, // This is an important bit, we need to set snrepo to our repositoryUrl so IdentityServer will know who should it talk to for authorization
}
```

- Wrap your app with a provider like this

```typescript
import { AuthenticationProvider, useOidcAuthentication, UserManagerSettings } from '@sensenet/authentication-oidc-react'
import { Repository } from '@sensenet/client-core'
import { RepositoryContext } from '@sensenet/hooks-react'
import React, { PropsWithChildren } from 'react'
import ReactDOM from 'react-dom'
import { BrowserRouter, useHistory } from 'react-router-dom'

ReactDOM.render(
 <AppProviders>
 <App />
 </AppProviders>,
 document.getElementById('root'),
)

export function AppProviders({ children }: PropsWithChildren<{}>) {
 return (
 <BrowserRouter>
 <AuthProvider>
 <RepositoryProvider>{children}</RepositoryProvider>
 </AuthProvider>
 </BrowserRouter>
 )
}

export const AuthProvider %3D ({ children }: PropsWithChildren<{}>) %3D> {
 const history %3D useHistory()

 return (
 <AuthenticationProvider configuration%3D{configuration} history%3D{history}>
 {children}
 </AuthenticationProvider>
 )
}

export const RepositoryProvider %3D ({ children }: PropsWithChildren<{}>) %3D> {
 const { oidcUser } %3D useOidcAuthentication()

 if (!oidcUser) {
 return <LoginForm />
 }

 return (
 <RepositoryContext.Provider value%3D{new Repository({ repositoryUrl, token: oidcUser.access_token })}>
 {children}
 </RepositoryContext.Provider>
 )
}
```

- That is it! 🎉 You can now authenticate with your user.


### What if I don't know the authority url?

You can get the authority and client_id config from the service with this action `https://my-service.sensenet.com/odata.svc/('Root')/GetClientRequestParameters?clientType%3Dadminui`

Photo by [Maxim Zhgulev](https://unsplash.com/@jemjoyrussia?utm_source%3Dunsplash&utm_medium%3Dreferral&utm_content%3DcreditCopyText) on [Unsplash](https://unsplash.com/s/photos/lock?utm_source%3Dunsplash&utm_medium%3Dreferral&utm_content%3DcreditCopyText)

We have changed the authentication mechanism for sensenet 7 to use IdentityServer4. 
Here are the things you need to know when you use it in a single page application.

2020-05-05-authentication-with-identity-server

Authentication to sensenet with IdentityServer4

In our busy world every minute is a waste of time if we should spend it with waiting. Of course we know that, and we are about to constantly improve performance to not waste your time.

## Divide it like Moses 🌊 

Check this pull request here: [#532](https://github.com/SenseNet/sn-client/pull/532)

As you already know we use webpack for module bundling in sensenet. Till that time, we did not care too much about the bundle size,
but our app is growing and growing so we had to change our mind and take some steps forward. 
The size of resources was ~57.3 MB and we had two opportunity for reduce:

1. We would use the [create-react-app](https://github.com/facebook/create-react-app) and its standard webpack configuration 
2. We would create our own webpack config(s). 

Because we use monaco editor and decorators in our code it is hard to match with create-react-app rules, so we have chosen the second option and divided our webpack configuration to 3 parts:

- one is for development purposes (webpack.dev.js)
- one is for production code (webpack.prod.js)
- and the remain is for both, commonly used settings (webpack.common.js)

We tried to follow the suggestions of create-react-app in this way as well.
Finally, we could reduce the resources size from ~57.3MB to ~8.1 MB with deploying 'real' production code with all its advantages like tree-shaking and source map removal. The transferred data became ~4.3 MB from ~12.7 MB so I declare with all confidence that it is worth the effort.

In the future, we would like to follow the changes what we can easily do with [RelativeCiAgent](https://relative-ci.com/). When we merge something to our develop branch RelativeCiAgent provides us a really transparent report of our bundle size.


<img src%3D"https://raw.githubusercontent.com/SenseNet/sncom-resources/master/img/posts/relativeCiAgentReport.png" alt%3D"relativeCI agent report">


I really like it when I have nothing to do, RelativeCiAgent do the 'dirty work' for me. 😁
Thank you for the authors and all the contributors!

We can also check the size during development as well. We just added a new line for the package.json: 
`"build:stats": "webpack --config webpack.prod.js --profile --json > stats.json"` 

After generating the `stats.json`. We can make this file more transparent with [webpack-visualizer](https://chrisbateman.github.io/webpack-visualizer/)


<img src%3D"https://raw.githubusercontent.com/SenseNet/sncom-resources/master/img/posts/webpack_visualizer.gif" alt%3D"webpack visualizer">


## Quality is not an act, it is a habit.

Check this pull request here: [#550](https://github.com/SenseNet/sn-client/pull/550)

For improving the quality of our app, we run [Lighthouse](https://developers.google.com/web/tools/lighthouse) on the admin surface's landing page. It was interesting to see what we missed during development. Okay these problems were small ones, but you know: "Many a little makes a mickle!" 


<img src%3D"https://raw.githubusercontent.com/SenseNet/sncom-resources/master/img/posts/lighthouse_before.png" alt%3D"lighthouse before">


Our main problem was that we used a gif file as a progress indicator, and it was full screen sized, a huge one. We decided to change it to one of the built-in loaders in material-ui. We also fixed some small bugs, like:
- Accessible name of `Button` elements,
- `alt` attributes of `Image` elements,
- `[lang]` attribute of the `<html>` element,
- missing `meta` tags on the document (meta description etc.).

Our final results after the fixes were the following:

<img src%3D"https://raw.githubusercontent.com/SenseNet/sncom-resources/master/img/posts/lighthouse_after.png" alt%3D"lighthouse after">


We were pretty proud of it. 😉 

## What's Next?

Our goal is to make the user interface useful and usable for every user, including those who have a slow internet connection. It is a continuous operation, we cannot say that 'We are done with it'. We would like to be better and come up with new ideas. For now we optimize our app for desktop only, but in our short-term plan we would like to do more for mobile as well.

So you know: "Time is money..", and we really appreciate your time.


<img src%3D"https://raw.githubusercontent.com/SenseNet/sncom-resources/master/img/posts/infinity_and_beyond.jpg" alt%3D"infinity and beyond">

How long will you wait for a website to load before you give up and go somewhere else? Five seconds? Ten seconds? Apparently, nearly half of us wouldn't wait three seconds.

2020-01-18-time-is-money

Time is money

## sensenet as a service

We decided to make sensenet available (in addition to the existing annual licensing model) also as a service, hosted in cloud. This will be our main focus for 2020. The idea of [sensenet as a service (or SNaaS)](https://www.sensenet.com/try-it/what-is-snaas) was exciting, we were super pumped about this new project! At the same time, it was difficult to know where to start.

Before moving a feet, the preparation took several months, and now, even if the system is still not active, we have taken big steps. I had to tell, that after clarifying our vision and defining several crucial points during long, but productive meetings there was a time, when I felt blocked. I was asking myself “ok, and now what’s next?”.

So nothing left, we started to work on “real, touchable” results. We have created a dev demo and involved early adopters, as we would like to have as many feedbacks as possible about the system.
We still have a lot to do. We are defining new goals for next year and also collecting data through surveys.


## hacktoberfest

Another big event for us in 2019 was [our very first Hacktoberfest](https://community.sensenet.com/blog/2019/11/06/surviving-hacktoberfest) 😊. It meant a lot of work, but at the same time it was very emotional to see such an active sensenet community with a lot of new followers! For sure we will repeat it next year! 😉

## admin ui & under the hood updates

Among several new features and improvements, the most important milestones of 2019 are the followings.
-	the new admin ui has been released this year. It is the brand new surface of sensenet, you can check the features and capabilities [here](https://www.sensenet.com/tryit).
-	we decided to refactor our data layer to make it simpler and extendable at the same time.
[learn more](https://community.sensenet.com/blog/2019/09/30/upgrade-dataprovider)
-	we are proceeding with .net standard support in 2020 as well


We want to make sensenet available to as many customers as possible, so we are constantly improving our product and come up with new ideas in the business side as well.
Looking forward to have you in our journey also next year!

At the end of the year you take a look back to see what you have achieved from your new year’s promises. Well, 2019 has brought lot of new things for us, and some of them was not even on the horizon at the beginning of the year.

2019-12-18-2019-sum-up

2019 sum up

But this year we decided to leave our comfort zone and take part as a company as well. Let’s see how we loved and hated this year’s October, how we overcome obstacles, what we’ve learned and what we can and will do better next year.

## The first one is always the hardest, they say

As I mentioned, this was the first time sensenet has taken part in the Hacktoberfest celebration as a company. The idea of participation came at the last minute and in the absence of experience we looked at others how to set goals and how to motivate the community to contribute. The whole thing looked a bit challenging, but the results from others have shown that it will be beneficial to all participants.

## Stop! Collaborate and listen

Since it was our first try, we did not set any concrete target like the number of expected pull requests or the minimum number of contributors. We only knew that we want to increase community engagement and product awareness. To make the opportunity to participate and contribute more appealing, we decided to offer extra swag as we have seen it from others. We did not know how many of you would be interested, so considering our options, we figured out that we would reward the first 100 participants with a limited-edition t-shirt and a sticker.

We wanted to involve as many people as possible, so we were looking for ways to get the message across. We wrote a blog post and share it through the social media channels where our company and our product are available. But the biggest boost came from sharing the post within a reddit thread, and it was quickly added to a [list and website](https://hacktoberfestswaglist.com/) of companies that give participants an extra gift.

To keep the hype alive throughout the month, we keep sharing the message with specific daily twitter posts, regular thematic newsletters, Facebook and blog posts and tried to answer all the questions and the actual pull requests as fast as we could.

As it was a last-minute thing, we did not have time to prepare enough suitable issues for newcomers. This is definitely a thing we need to improve in the future.

## Totally worth it

Let’s look at the results in numbers. Over 250 of you have registered through the form on our website. I would like to thank you once again for your interest. We didn't expect so many applicants, we really appreciate it, you’re awesome!


 <img src%3D"https://raw.githubusercontent.com/SenseNet/sncom-resources/master/img/posts/worth-it.jpg" alt%3D"worth it">


In a typical month there’re 25 pull requests overall made in the repositories of our [GitHub organization](https://github.com/SenseNet). This is not a huge number, but we’re a small team, so you can imagine how big it is for us, that you’ve made **287 extra pull requests** in this month. 😲 These pull requests were made by **more than 200 new contributors**, which is pretty awesome. We are very sorry that we cannot reward every one of you, we will surely figure out something to level up next year in this thing as well.

Although Hacktoberfest 2019 is over, we are looking forward to hearing from you anytime. All your feedback and help is important to us, any ideas, fixes and questions are welcome.

[Hacktoberfest](https://hacktoberfest.digitalocean.com/) was a popular event among our product developers in the last couple of years. Since we’re open source, it was obvious to us to join and celebrate it in our ways, giving to the community what we are good at.

2019-11-06-surviving-hacktoberfest

Surviving Hacktoberfest

👕 Help us to grow community around sensenet making a pull request in one of our repositories and join those who are already part of the celebration! 🎃

## How It's Going So Far 🚀

Being the middle of october is a great opportunity to take a look back and see how far we get together and also to see what else could we achieve in the next few weeks.

As you probably know sensenet rewards the first 100 contributors with an extra swag (limited edition sensenet hacktoberfest t-shirt and a nice sticker) if they join us in celebration by registering [here on this form](https://sensenet.com/Hacktoberfest2019). 170 of you applied to participate so far, but don't worry, not all of them did meet the other requirement up to now. Although almost 250 pull requests was made by you in the last two weeks, 25 more t-shirts are left to reward some of you with them. 🎁 

We’re looking forward to seeing what else you’re working on, so if you’re still heading toward hitting your goal, here’s some inspiration and a few tips to get started.

## Ideas on where to start

As we stated at the start of hacktoberfest, the issues which we believe can be easily accomplished are marked with the ```hacktoberfest``` label. It is still the case, despite the fact that such tasks, especially the very simple ones, were taken very soon. We continue to encourage everyone to choose from these issues and look back to 👉 [this list](https://github.com/search?q%3Dorg%3Asensenet+label%3A%22hacktoberfest%22+is%3Aopen&type%3DIssues) 👈 as often as possible, new tasks are constantly being added.

## Quality standards

As some of you have experienced, there are cases where issues are labeled as ```invalid``` by us (which means the labeled pr is not count and you you won't get +1 until you do another, non-invalid PR). Yes, we said in the [previous blog post] that every little change counts, but at the same time it wouldn't be fair from us to accept a request _"that's clearly an attempt to simply +1 your PR count for October"_. Please accept that we follow the [hacktoberfest quality standards](https://hacktoberfest.digitalocean.com/details#quality-standards). If you believe that your PR was unfairly flagged as invalid, please begin a conversation within the related PR and explain your position.

Lastly, for related news follow us on [Twitter](https://twitter.com/sensenet). We strive to provide #hacktobetfest relevant information every day during october.

We have already left the halfway point for Hacktoberfest 2019, but it's still not too late to jump in and get your extra swag!

2019-10-16-hacktoberfest-halftime

Hacktoberfest halftime show

<img src%3D"https://raw.githubusercontent.com/SenseNet/sncom-resources/master/img/posts/hacktoberfest2019.png" alt%3D"Hacktoberfest 2020">


This year we want to take it to the next level and increase participation in our project by encouraging developers to contribute. The first 100 participants who makes a pull request to any of the repositories under the Sense/Net organization on GitHub between October 1 and October 31 will receive a sensenet #hacktoberfest limited edition T-shirt.

## How to participate

- Register for the event on the [Hacktoberfest website](https://hacktoberfest.digitalocean.com/register).
- Share your contact details with us via [this form](https://www.sensenet.com/Hacktoberfest2019) so we will know where to send your t-shirt when Hacktoberfest ends.
- Make at least one pull-request in one of the repositories under the Sense/Net organization. Note that contributions don’t have to come in the form of code. Improving documentation is also a great place to start.

Since we keep and manage our backlog on github, you can run through the possible tasks easy. Not just the source code but all the documentation and even this blog post is stored under one of our public github repositories so feel free to discover them. Any contributions are welcome no contribution is too small. To make the process smoother we marked couple of our already existing issues with the ```hacktoberfest``` label. Exploring [the list of these labelled issues](https://github.com/search?q%3Dorg%3Asensenet+label%3A%22hacktoberfest%22+is%3Aopen&type%3DIssues) could be a good starting point.

While you only need to make one pull request to receive a shirt, you're welcome to make as many as you like. Our repositories are written with various different languages or frameworks (C#, TypeScript, ASP, React, etc.) so you can easily find your match. 

Come and join our celebration! Our team is eager to hear your feedback and we will do our best to make your contribution a success.

🔥 Happy Hacktoberfest! 🔥

Open source and community are key for us since the beginning of product development. We are committed to support the movement with helping developers expanding their skill set and make the community bigger, not just around sensenet, but globally.

2019-10-01-hacktoberfest-is-here

Hacktoberfest 2019 is here

We decided to refactor our data layer to make it simpler and extendable at the same time. The goal is to make it possible for 3rd party developers to create custom implementations for any platform and let us use modern development approaches - like asynchronous data handling.

## Do I need to deal with the upgrade?
If you create a new project or work in a development environment where you re-build your database frequently, you do not have to deal with the upgrade: just get the latest sensenet packages from nuget, install the new db and you're done.

If you have a working live db, you'll need to execute an **upgrade patch**. This is similar to the usual SnAdmin patch, but as it modifies the database structure **it may run for some time**, depending on the size of the database.

There are a few changes in the API that may cause build errors but there are not many of them. 

> **Existing provider implementations**
> 
> The only exceptions are low-level providers for database, indexing and messaging. We could not keep the old APIs because that would mean duplicated implementations in some cases. As these APIs have changed significantly, if you created one of those and experience API issues after upgrading, please contact us for support.

## What has changed?
We cannot list all the small changes here, but there are a few major themes that are important.

### High level APIs
The good news is that there are no significant changes on the `Content` and `Node` layers. This was an under-the-hood data layer refactor project, so most of your code will remain unchanged.

### The new DataStore API
Apart from the usual Content CRUD operations sometimes developers need to access the data layer directly. The new entry point for that is the `DataStore` class that holds the public interface for these operations. If you experience a build error after updating to the new package, please look for database operations on this new API, or use the `DataStore.DataProvider` property directly if necessary.

### Async API
One of the main features of the new API is that all data access methods became _asynchronous_. This means they return a `Task` that you can `await` for making the application a lot more resource-friendly and its throughput _a lot_ higher.

### Custom data providers
It has become a lot easier to port sensenet to another data platform. The data provider API is simpler than before and there are built-in base classes that you can inherit from, no need to start from scratch. For example:

- **MsSqlDataProvider**: use this base class if you want to remain on the MS SQL platform, but need to change part of the functionality - e.g. you want to store properties in a different way than we do.
- **RelationalDataProviderBase**: this is a good start for implementing sensenet on a relational db platform different from the built-in MS SQL implementation - for example MySql. The scripts and algorithms are reusable, you may need to change only a few things.

If you want to port sensenet to a totally new kind of platform (e.g. a NoSql solution) then you have the `DataProvider` base class to inherit from.

### Data provider extensions
Previously the data provider API contained data access methods for many features. This means custom db provider developers needed to implement all these methods, regardless of whether they needed those features or not.

From now on we will add new feature-specific data access functionality as [data provider extensions](https://community.sensenet.com/docs/dataprovider-extension). These extensions are new interfaces and classes marked with the `IDataProviderExtension` interface. The platform-specific class contains the implementation of the feature for that platform. For example the `ISharedLockDataProviderExtension` interface defines the required methods for the shared lock feature. The `MsSqlSharedLockDataProvider` contains the MS SQL implementation for the methods. 3rd party data provider developers need to implement those methods on their platform (e.g. MySql or MongoDb) _only if they need the feature_. The advantage of this approach is that we can keep the core data provider API relatively narrow.

Photo by [Andrea Cau](https://unsplash.com/@andreacau?utm_source%3Dunsplash&utm_medium%3Dreferral&utm_content%3DcreditCopyText) on [Unsplash](https://unsplash.com/images/travel/new-york?utm_source%3Dunsplash&utm_medium%3Dreferral&utm_content%3DcreditCopyText)

The data structure of sensenet has been more or less the same for many years. We added more and more features and the API became huge and was very hard to maintain, not to mention custom implementations for other data platforms.

2019-09-30-upgrade-dataprovider

Introducing the new data provider

## How it all begun

Our admin page is quite clunky and is hard to work around. The main navigation is the BFT (aka the big fucking tree) which can be overwhelming if you’re not familiar with the folder structure and can give you a hard time.

We decided that we should give it a new look and make it easier to navigate around the admin system so it will save time and will be a much pleasant experience to work with it. The only thing was… it’s pretty complex and as a designer I haven’t worked with it so I didn’t know the real depths of the admin system.

Long story short after a few days of thinking how I can solve this problem and that wasn’t an easy task at all. I was stuck and basically had no idea how to start the whole redesign thing when there was so many things to consider. That’s when the lightning of idea struck. **Let’s do a design sprint!**

After talking with the team members and they were down to do the sprint we started the preparation with our PM.


## The Sprint

Since it was our first sprint we heavily relied on Jake Knapp’s design sprint methodology. Me and our Pm who was the facilitator throughout the sprint started preparing for the week ahead of us, read through a mountain of articles and videos of best practices what should we pay attention to etc… and there was Monday morning.

### Monday

On Monday we went through the problem we were facing which is how can we simplify the admin page so it can be used faster and easier. After we set the goal, got through the map, asked the experts (people in the company who are using the admin site on a daily basis). By the end of the day we indeed got an idea where we should put our focus on which was that we don’t need to show the whole tree structure all the time because people who use the admin page just didn’t need it.

![Map with HMW notes](/img/posts/design-sprint/Map-with-HMW-notes.jpeg 'Map with HMW notes')

### Tuesday

After we picked the target it was time to focus on how we can solve the problem. We got through the lightning demos where we checked out how other companies solved this problem. Then we sat down to draw our solution sketches which turned out really solution sketches in the most literal way.

Because I’m the only designer in our team the sketches the team made were mostly focused on one single thing like query building, tree structure vs breadcrumb etc.. but it was very helpful for me as we moved deeper into the midst of the sprint as I was able to understand better and better how should we improve.

### Wednesday

We have a bunch of solutions! **Yeeey!!** Now it was time to choose the best ones. We critiqued every solution and in the end we did came up with three winner solutions. After that we started the storyboarding session which ended up with no story board at all 😀 but it was even more beneficial than the sketches in Tuesday in terms of the team really got on the same page what we should do. It was long and exhausting but none the less very beneficial brainstorming where the team went through and over and very deep into every little detail. **And it worked!!!**

*So no storyboard but a pretty solid plan on what we should do on Thursday.*

![Lightning demo captures](/img/posts/design-sprint/Lightning-demo-captures.jpeg 'Lightning demo captures')

### Thursday

Prototype time! This day was a bit strange in terms that in the sprint it says that the whole team should participate and no coding is allowed. Yeah right.. just try to do that in a team of developers. And as everything else in this sprint, worked out for the better in the end.

Me and my front-end developer teammate were the guys who did the prototyping. I did my part in Adobe XD and he did his in HTML so we ended up with two prototypes simultaneously which were pretty low fidelity. Again, it was against the sprint rules but seriously who gives a damn at this point after we improvised and tweaked here and there already.

We decided that we will prototype a scenario where the tester needed to find a file a few levels deep in the folder structure. I did the part where the tester could only find the file as he clicked through the structure. We decided that we wouldn’t throw out the whole tree structure but show only the relevant part of it to the user.

The other prototype looked the same but the tester had to use the search bar and try to find the file typing.

### Friday

Friday Funday Test day! We recruited 8 people to test out the prototype and after the tests it was pretty clear that we are moving in the right direction. The testers liked the new interface although it’s far from everything you can call done and both of the search methods were clear to all of them and they told that they could benefit from the new admin site in their day to day work after it gets done.

## Key Takeaways

I can call this first design sprint a success and it showed that we are on the right track resolving the problem although the real work will just begin. We’ll do a fully functioning high fidelity prototype and after another round of testing it can be implemented into working code.

To all other designers who are the only ones in their team and on the fence about conducting a design sprint. **Go for it!** Improvise, bend the rules a bit if you have to (we’re creative people after all) and have fun. You can help your developer teammates to have a little more insight about what you’re actually doing as a designer and you will appreciate more their work as well.

A design sprint can really improve the workflow, communication and creativity among the members and nonetheless it helps to get the whole team on the same page.

Thanks everyone for the read! See you all in the next one!

Recently I got a new task which was to rework our admin UI.

2019-02-01-sn-teams-first-design-sprint

SN Team’s first “design” sprint

## TL;DR
*We moved all our javascript packages to [one repository](https://github.com/SenseNet/sn-client).*

## Some history about our client packages

At first, we started with one package [sn-client-js](https://github.com/SenseNet/sn-client-js). As time went by it grew bigger and we felt like we need to do something.

> We’ve started 2018 with a huge package refactor: we have divided our base sn-client-js package into several smaller ones and published them within a @sensenet scope.

You can read more about that in another blog post ➡️ [Scoped packages](/blog/2018/02/21/scoped-packages 'Scoped packages')

## The problem

Managing features that span many repositories started to be difficult after the decoupling. Staying on the same version of typescript, using the same rules in the tsconfig. We had to do all those things in every repository.

For example, we have a package called [@sensenet/client-utils](https://www.npmjs.com/package/@sensenet/client-utils) and I want to add a new helper function there.
Let's say a debounce that I will use in another package.

### The workflow is the following for this:

1.  Create a branch from develop in the client-utils package
2.  Create the debounce function
3.  Create a pull request and wait for the code review
4.  Merge back to develop
5.  Do a release
6.  Do a package upgrade in the package I want to use the util function
7.  Notice a bug in the debounce function and start a process again

I know, there shouldn't be a bug in the code that have been reviewed. Also we could just copy the built code to the package node_modules folder to use that instead of the package from npm but that felt like a pain in the long run. There must be an easier way for this.

## Monorepo to the rescue

> In revision control systems, a monorepo (syllabic abbreviation of monolithic repository) is a software development strategy where code for many projects are stored in the same repository.

**In a monorepo the whole workflow can be simplified like this:**

1.  Create a branch from develop
2.  Create the function
3.  Build, test
4.  Merge back when done

So much easier and cleaner than before. No need to copy anything, anywhere. No need to release a dev alpha or a minor version. You can see your changes in all the packages once you modified something. It not only made our life simpler but it gave us a productivity boost as well. Let's see how the transition went.

![Patrick](/img/posts/monorepo/patrick-meme.jpg 'Get all the packages we extracted from one repository and put them together in a new one')

## Moving sensenet client packages to monorepo

First thing first, we need a new repository. We could also use one of the repos and put everything there, but it felt cleaner to start a new one. I have created a todo list in this [pull request](https://github.com/SenseNet/sn-client/pull/1) to track the progress and to see what is left. 

We moved all the packages to the packages folder with Lerna. _[Lerna](https://lernajs.io/) is a tool that optimizes the workflow around managing multi-package repositories with git and npm._ This way we could see the commit history in the new repository as well. We had to make sure that every package is able to build itself. We faced some problems here. Not every package was configured correctly. Some was missing dependencies that were needed for it to be able to build.

After that we run the tests to make sure we didn't break anything. Because the repositories were not consistent in their configs, it failed. We had to temporarily suspend the linting to see the test results. With that said we realized that we should make all repositories consistent. Fortunately there were no big errors.

This is the list that we did to make the packages unified:
  - Styling - Added .editorconfig, prettier and precommit hook with [lint-staged](https://github.com/okonet/lint-staged)
  - Linting - Pointed the tslint.json files to the root tslint file and fixed the errors
  - Build - Pointed the tsconfig.json files to the base tsconfig file
  - Updated the package.json files to reflect the new changes (issue link, git url), removed common devdependencies
  - Removed files that are not needed anymore in all the repositories (travis.yml, contributing.md, .vscode folder)

When we finished with all this we had to make the ci work again, update the readmes, archive the old repositories and move all the issues to the new repository. The last step was to do a minor release from the packages. It was a piece of cake with the help of Lerna.

### After all here are the benefits we gained:

- **It is easier to coordinate changes across modules** - Because every package that depends on another is linked together, you can see the changes in no time.
- **Dependencies are now unified** - In a multiple repository environment where multiple projects depend on a third-party dependency, that dependency might be downloaded or built multiple times. In a monorepo the build can be easily optimized, as referenced dependencies all exist in the same codebase.
- **Single lint, build, test and release process** - Monorepos can share their configs from top to bottom creating a consistent developer experience.

## Conclusion

I think that moving to a monorepo will help us in the long run. Getting everything configured took time but it was only necessary for the future.

_Juggling a multimodule project over multiple repos is like trying to teach a newborn baby how to ride a bike._ [Babel](https://github.com/babel/babel/blob/master/doc/design/monorepo.md#why-is-babel-a-monorepo)

2019-01-10-moving-client-packages-to-monorepo

Moving sensenet client packages to monorepo

We began developing DMS – our document management solution –  as an MVP roughly about a year ago, this is why: sensenet is a [headless content management platform](https://community.sensenet.com/blog/2017/07/05/what-is-a-headless-cms) where the backend does not care about how the content is displayed. If you are a frontend developer, this gives you freedom of choice in what tools you use and how you want to implement your solutions. To give you guidance, however, we also wanted to create an example implementation for a real-life business need. Feedback from partners and users indicated that a simple web based file management would be a good start. And then, DMS was born.

## Use it, or build your own

*… Alice had begun to think that very few things indeed were really impossible.*

We also knew that that you will need reusable building blocks and tools as well for your own solutions, so we created small, lightweight [frontend packages](https://community.sensenet.com/blog/2018/02/21/scoped-packages) that are optional, but considerably speed up frontend development with sensenet. DMS, on the other hand, has outgrown the original MVP, so it just seemed logical that we generalize many of its functions in our underlying packages.
Now you can:
*	Use DMS as is: Install SN7 backend packages, then add the DMS frontend package on top of it, and just use as a sample application. It will take care of dependencies.
*	Use the generalized packages for development: This is the recommended method if you want to build your own production ready solution. Install SN7 backend packages, then build your application with the underlying building blocks we also used in DMS.

Both ways you are future proof if you do not fork: it will be easy to upgrade to our new releases, and you can get support from the community or from the core development team.

## Looks and functions

*…"and what is the use of a book," thought Alice "without pictures or conversations?"*

Besides classic web based file management functions we were serious about creating an ergonomic, intuitive, modern and appealing user interface. Additionally, since we have sensenet in the background, we built the UI on already existing, useful functions.

Checking content in or out:

![DMS - checking content in or out](/img/posts/dms-1-0-checked-out.png "DMS - checking content in or out")
 
Publishing, with optional approving or rejecting:

![DMS - approve or reject](/img/posts/dms-1-0-approve-or-reject.png "DMS - approve or reject")

Creating and restoring major and minor versions:

![DMS - versions](/img/posts/dms-1-0-versions.png "DMS - versions")

As an example, we also integrated our recently published standalone [document viewer](https://community.sensenet.com/blog/2018/08/22/docviewer) solution: 

![DMS - Document Viewer integrated](/img/posts/dms-1-0-document-viewer.png "DMS - Document Viewer integrated")

And of course, you can also share folders or files:

![DMS - sharing](/img/posts/dms-1-0-share.png "DMS - sharing")


## You can do it too

*"Why," said the Dodo, "the best way to explain it is to do it."*

This is what you need to build your solution:
*	Install [backend packages](https://community.sensenet.com/docs/install-sn-from-nuget/) and make the most of sensenet’s [content repository](https://community.sensenet.com/docs/content-repository/) and any of its its optional extensions. Among others they already know about content operations such as create, upload, modify, delete, copy and move, handling metainfo and storing binaries, managing indexing and search, powerful and fast security, background task management for preview generation, and even versioning and approval and related functions, such as version history and restore.
*	Install the [frontend packages](https://community.sensenet.com/blog/2018/02/21/scoped-packages) you need.
*	Use the JavaScript/Typescript client API to rapidly develop your project.

Remember, its [completely free](https://www.sensenet.com/product/licensing/sense-netlicensingguide).

*“Begin at the beginning,” the King said, very gravely, “and go on till you come to the end: then stop.”*

2018-10-25-document-management-built-on-sensenet

Document Management built on sensenet

That's exactly what happened with sensenet's Docviewer, so as the newest addition to the product team as a UX designer my first task was to reimagine and redesign the app.
In this article I'll guide you through the steps including user interviews, making wireframes to high fidelity prototypes, user testing, iterating and so on. 

## The first steps
My work began with sitting down with the team and discussing what our main goal was (simplify the app and get rid of unused features). After that I started looking around for best practices like how other document viewer apps look like and what features they have. I used [Adobe Acrobat](https://acrobat.adobe.com/hu/hu/acrobat/pdf-reader.html), [Lumin](https://www.luminpdf.com/), and [Apple Preview](https://www.apple.com/lae/ios/ios-12-preview/) as starting point. 
Since we wanted an app with mostly viewing capabilities and a little bit of editing qualities, Apple preview was the closest to our concept.

After clarifying the main path that we should take, I conducted a few user interviews (six to be exact) to find out what people mainly looking for when they open a document viewer. After the interviews were done and evaluated each interviewee's answers I began to make the wireframes. After several versions there was a clear winner chosen by the team and from there the prototyping began.

![Wireframes](/img/posts/Wireframe.png "Selected Wireframes")

## Prototypes
After the wireframing I made high fidelity prototypes in light and dark mode. For the high fidelity prototype I used [Sketch](https://www.sketchapp.com/) and followed [Material Design](https://material.io/design/) principles. I also made a click through prototype in [InVision](https://www.invisionapp.com/) which you can try as well in the following link: [Docviewer](https://projects.invisionapp.com/share/TGJZD5KNQZU#/screens)

![Prototype1](/img/posts/Docviewer-Active-Light.png "Prototype light")

![Prototype2](/img/posts/Docviewer-Active-Dark.png "Prototype dark")


## User testing
When the click through prototype was finished I did a user testing session which included 5 people.
I asked the participants to follow through these steps:
1: Open the edit feature
2: Open the left sidebar
3: Go to page 2 and 3 then go back to the top of the page
4: Open the comment section
5: Zoom in and out
6: Rotate the page to the left and then back to its original state


## Iteration
After finishing the user tests I evaluated the answers and there were a few things that needed to be changed. First of all, the left sidebar icon was very unfamiliar for most of the participants and they had a hard time finding it, so I had to find a more straightforward icon. Most participants liked the comment function and said it would benefit them. Also, most of the participants didn't like that the rotate buttons were on the bottom of the page, so I moved them to the top navbar.

![Iteration](/img/posts/Docviewer_mockup.png "Iterated design")

## User testing part2
I updated my design after the first set of user tests and I conducted a second round test with the same participants. The results were much better this time and everyone made through the tests without any problem. The new sidebar icon solved the problem and putting the rotate buttons to the top navbar helped a lot as well. I also changed the order of the icons in the top navbar so the zoom icons were next to the rotate and sidebar, download, print and share buttons were next to each other.

![Iteration](/img/posts/Docviewer_mockup.png "Iterated design")

When I had the second round of user tests I sent the results and the updated screens to the team who are working hard to make the 1.0 version alive which will not include the comment function and the editing capabilities but those features will come as well very soon!

**Thank you for reading my first article! More will come in the future!**

Sometimes there is a strong need to rethink an app from the ground up, because it has became too chunky and difficult to use with a lot of features that no one actually used.

2018-08-22-docviewer

The new and improved Docviewer

This is why we started to unify our projects to support [.Net Standard 2.0](https://docs.microsoft.com/en-us/dotnet/standard/net-standard) that contains a lot more APIs than its predecessors.

## A unified .Net platform
To offer at least parts of sensenet in .Net Standard format, we have to upgrade all our libraries to **at least .Net Framework 4.6.1**, because that is the oldest version on the framework line that supports .Net Standard 2.0. This already happened in the last few days: we released a new version of our components containing the new libraries.

This means that starting with **sensenet Services 7.2** the application project that uses sensenet packages has to be at least on .Net Framework 4.6.1 or later. This should not be a big deal as that version is relatively old.

> **Important**: please note that there was a [type forwarding issue](https://github.com/dotnet/standard/issues/300) in .Net Framework 4.6.1 that breaks interop with a netstandard assembly if it contains certain methods in a class marked as Serialized. This means that although your projects may be on 4.6.1, on the target (executing) machine at least **.Net Framework 4.7.2** has to be installed.

## I'm confused, .Net Framework, Core or Standard?
sensenet consists of many libraries. The goal is to offer these libraries to the broadest customer audience possible. The .Net Standard format lets both **.Net Framework** (4.6.1+) and **.Net Core** (2.0+) applications use our packages. This lets older projects get the new features while modern environments (for example a full cloud-ready build and deployment system) can also use the same code base.

> But we are not there yet.

## Converting sensenet libraries
There are some features or APIs in sensenet that are **not available in .Net Standard** (of course in a future version of the standard there may be more APIs available but we can only work with what we have now): *EventLog* access, *MSMQ messaging* and *Workflow Foundation* among them. Our approach is to replace these features with more modern solutions or separate them into their own components and make them available as a legacy option. 

There are other reasons for decomposing some features: as MSMQ is **not available in the cloud**, we will offer a different solution (based on *RabbitMQ* or *Azure Service Bus*) for messaging in cloud deployments.

This means we will convert our projects one-by-one, starting from the bottom. *SenseNet.Tools*, *Common*, *Search* and a few other libraries are already converted to netstandard, as you can see in the following diagram.

![Converting projects to netstandard](/img/posts/netstandard_diagram_01.png "sensenet netstandard libraries")

As we move forward with this project, we will post updates on how many and what kind of issues we have left and which packages are converted to netstandard.

## How does this affect my project?
You should not notice much - at least at the beginning. When we release a new version, NuGet will take care of updating your dll references. 

We try to convert or move features in the background, without changing the API if possible. When we remove and replace a dependency (e.g. *Enterprise Library* soon) you'll have the option to use either the old or the new technology (in this case a more modern, service-oriented logging module).

## Easier upgrades
Ok, but does not this mean that I'll have to update sensenet packages too frequently and execute patches all day?

> Fortunately not.

Our components (e.g. Services, WebPages) have two parts: libraries and a database part (e.g. content type definitions, views, etc.). If *only the dll part changes* (as is the case when we refactor the code base in the background), you *do not have to execute an SnAdmin patch*, because the dll is still compatible with the content items in the database.

Starting with sensenet 7.2, our components know the last supported version for their database part, so if there were no changes in the content repository, you can just **update the NuGet package in Visual Studio** and compile your application!

Photo by [rawpixel](https://unsplash.com/photos/FWOGqSKq_Cs?utm_source%3Dunsplash&utm_medium%3Dreferral&utm_content%3DcreditCopyText) on [Unsplash](https://unsplash.com/search/photos/standard?utm_source%3Dunsplash&utm_medium%3Dreferral&utm_content%3DcreditCopyText)

There is a lot going on with .Net these days. First came the new era of .Net Core, then a new standard emerged that serves as a bridge between the old and the new platforms. We have to make sensenet available to as many customers as possible.

2018-07-09-netstandard-first

A road to .Net Standard

Online document editing is also a requested feature so we are working to implement Office Web Apps Server to sensenet in the coming months. Read our article to get some updates about plans and goals for Q2 2018.


### SN6 to SN7 - Patch is coming

As we no longer provide updates for older versions of sensenet, it is crucial to upgrade every project to the latest version. We are working on a patch which can upgrade existing projects from version 6 to the latest release. Once upgraded to SN7 you can easily install future patches for this version and keep your solution up to date.

We plan to publish this upgrade patch in Q2 this year. Stay tuned as we'll share more info about development process in the coming weeks.

### Cloud compatibility
![Cloud compatibility](/img/posts/cloud_compatibility.jpg "sensenet goes to cloud")
The next milestone in the lifetime of SN7 is cloud compatibility which involves lot of additional researches and developments. 

Read about one of the biggest challenge below:

#### Messaging and cache
We will start working on refactoring messaging and caching in sensenet by examining the industry standard and implementation opportunities. During the first phase we’ll create a study from the current state and opportunities, then we can move on by forming needs and actions for future improvements to modernize messaging and caching. As cloud compatibility is already in the corner, sensenet messaging in cloud environment is also a hot topic in our product team.

### sensenet UX revamp
![UX revamp](/img/posts/excavator.jpg "UX revamp")
After so many under the hood changes like the componentization, as one of the biggest upgrades in SN7, the user interface will get an overhaul as well. 
We want to create a UI which is future proof and amazig to use, so we started working with UX researchers who are contacting our partners to collect as much feedback as he can.

We would like to understand how people really use sensenet and make it more simple and easy to understand, so you’ll find every button, controls and other elements at the right place, you won’t need to search for them.

The core concept of this revamp is to create the first building blocks of a new simplified user interface with only the required features and separate it from the content explorer.
Users will be able to edit permissions, view and manage document but they won't have access to the content explorer (which will be also rewritten) and to more advanced options.

Stay tuned because we’ll share more info about the new sensenet UX in the coming months.


### DMS v2.0
In Q2 we will publish the 2.0 version of our document management system which is started back in 2017 as a DMS MVP project. Now we want to go further by implementing the following features into the 2.0 version:
- Copy and Move action
- Improved path picker
- Real time document editing

Check out the current state of the DMS right [here](https://github.com/SenseNet/sn-dms-demo). 
Feel free to clone and explore the solution. 

### Standalone DocViewer

SN 7 features a powerful [Preview Component](https://github.com/SenseNet/sn-preview) which can be used in any project. The DocViewer is responsible for displaying preview images of documents, however it's the role of the preview generator to create these "images" for the DocViewer. Currently we are using Apose's solution for this task.
Our goal is to separate these parts and publish a standalone DocViewer which can be used with any preview generator in any project. This standalone DocViewer will be written entirely in JS and it won't have any ASP.NET dependencies.

### Online document editing
![Online editing](/img/posts/online_doc_edit_typewriter.jpg "Online editing")
Many of our partners requested online document editing in addition to the current WebDAV solution so we will integrate Office Web Apps Server to sensenet. According to our roadmap we plan to publish this solution as part of the product in Q2 this year.

### More training materials and tutorials
As we promised we are working constantly on training materials. 
In Q1 we published our first video tutorial of the SN7 era and we constantly migrating articles from our wiki site to the new community site. In most cases some modification is needed, so we review and update all articles before posting them to community site. Check all updated and new docs on our [community site docs section](https://community.sensenet.com/docs/).

In Q2 there are some very interesting plans on our roadmap like SN6 to SN7 upgrade patch, Cloud compatibility developments to prepare sensenet for Azure and later to other cloud based environments and a huge UX revamp project to name a few.

2018-05-09-q2-goals

Product goals for 2018 Q2

We decided to publish every feature in both Enterprise and Community Edition of sensenet, and we've done many improvements in the core service layer and in the components as well. Read our post to learn more about Q1 in sensenet.

## Tutorials
![tutorials](/img/posts/signpost.jpg "tutorials")
As SN7 opened a whole new way to develop with sensenet, many tutorials are needed to support early birds, who wants to start using these new possibilities.
Now you can work with sensenet using your favourite JS framework or even MVC. At the moment, we provide tutorials for MVC, ReactJS and Aurelia, our most preferred JS frameworks.

- [MVC](/docs/tutorials/starting-out-with-mvc/)
- [reactjs](/docs/tutorials/starting-out-with-reactjs/)
- [aurelia](/docs/tutorials/starting-out-with-aurelia/)


## IR Decoupling
We started working on the Information Retrieval module refactoring project back in Q4 last year. This module is responsible of indexing and querying within sensenet.
See what we achieved in IR decoupling in the past three months.

- [IR Renewal project](https://github.com/SenseNet/sensenet/issues/125)
- [Standalone Lucene search module](https://github.com/SenseNet/sn-search-lucene29)

## JWT improvements
![jwt improvements](/img/posts/lock_jwt.jpg "jwt improvements")
In SN7 you have the opportunity to use [JSON Web Tokens](/docs/tutorials/how-to-use-jwt-in-sn-client-js/) to authenticate users. In the last few months we've made the following improvements concerning JWT Authentication.
- Users have the option to log out from all devices with a single click
- Password change now triggers a force log out on all devices
- Session is destroyed on logout
- Login extender and audit log works with JWT the same way as with forms auth

## Preview component and AD Sync

In Q1 an important decision was made concerning the Enterprise only features of sensenet, therefore we will publish each and every feature as part of the Community Edition, including AD Sync and Preview Component as well.

For that reason the [Preview component](https://www.nuget.org/packages/SenseNet.Preview/) and [AD Sync](https://www.nuget.org/packages/SenseNet.SyncAD2Portal) NuGet packages are available for any sensenet 7 solution even without having Enterprise licences.

## First SN7 patch
![sn7 patch](/img/posts/sn_patch_bear.jpg "sn7 patch")
In February the first patch for sensenet 7 has arrived with several bugfixes and features.
At the time of writing, the sensenet 7.1.1 version is already out.
Follow releases on [GitHub](https://github.com/SenseNet/sensenet/releases) to keep up to date.
Read our [tutorial](https://community.sensenet.com/blog/2018/02/14/install-patch) about installing patches in sensenet.


## Scoped packages

The whole idea behind scoped packages was to divide overgrown client side packages into smaller ones and publish these new, refactored packages under @sensenet scope.
Simplifying API and get rid of external dependencies like RxJs library were also among our goals when we started this project a few months ago.

Take a look at our new packages and their dependencies:
![Scoped packages](/img/posts/scoped-packages-dependencies.png "scoped packages dependencies")
[Learn more](/blog/2018/02/21/scoped-packages) about what we achieved in Q1 with npm packages.


## Release sn7.1
Back in March, [sensenet 7.1](https://github.com/SenseNet/sensenet/releases/tag/v7.1.0) was published packed with many under the hood changes. Major changes were made in indexing and querying generalization. All of these modifications are needed to prepare Lucene search engine to work as a service instead as a local index. In this first phase no changes have been made in architectural level, however you may need to rebuild or update some libraries before executing the patch due to some API changes.
Please read our [post](https://community.sensenet.com/blog/2018/03/05/complex-patch) to learn more about the changes and the installation process.

## Testing
We have a huge amount of tests in sensenet, that's why their runtime and effectiveness are really important. Before SN7, we used more than 1400 tests and most of them were integration tests which required a fully installed sensenet and lot of time to run. We decided to [start over](/blog/2017/10/27/in-memory-testing) and use unit tests to increase effectiveness of testing and development.
The new tests are intended to test small pieces of the source code without depending on other parts, therefore we can quickly locate errors without reviewing the whole code. Another important point is that the runtime of these tests is now much shorter so we are able to run more tests in less time.

## What's next
As you can see above, so many things happened with sensenet in the first quarter and we will continue improving the product based on our goals and your feedback as well. We will be back soon with another article about Q2 goals so stay tuned. In the meantime if you have any idea to improve sensenet, a [pull request](https://github.com/SenseNet) is always welcome.

Q1 was quite successful in terms of the product roadmap. We published many [tutorials](/tutorials/) and [documentations](/docs/) on our community site to help you start working with sensenet.

2018-05-02-q1-results

First quarter's achievements

Following will sum up all the changes, the why's and how's including a list of the possible migration steps if you used a previous version of sn-redux before.

## Scoped package

![Clean-up](/img/posts/cleanup.jpg "Clean-up")

As it was mentioned in one of our previous [posts](https://community.sensenet.com/blog/2018/02/21/scoped-packages), with creating scoped packages our main goal was to divide the code into smaller and more maintainable units. We've created *@sensenet* scope and publish our npm packages within this. With sn-redux the plan was the same, so [@sensenet/redux](https://www.npmjs.com/package/@sensenet/redux) was born. From now on the package should be installed like this:

```npm install --save @sensenet/redux```

This way it will be saved in a separate folder named *@sensenet* and the inner modules have to be imported this way:

```import { Actions } from '@sensenet/redux'``` 

## Dependency clean-up

The list of dependencies of previous versions was quite huge so we've decided to think about how to reduce the number of them. First step was to remove everything related to [gulp](https://gulpjs.com/). Since the last version we only use it in one task to help generating docs with [typedoc](http://typedoc.org/), but it became unnecessary with some improvements in our npm scripts so [gulp](https://gulpjs.com/) related dependencies could have been removed. Some of the tools were removed because they add tons of dependencies indirectly while they're necessary only in our development process, so because of this we decided to install things like [typedoc](http://typedoc.org/) or [commitizen](https://github.com/commitizen) as global dependencies in the future this way they could be removed from the list of dependencies.

## Replacing redux-observable epics and removing rxjs

The biggest improvement of the new release was refactoring async operations. We have been using [rxjs](http://reactivex.io/rxjs/) and [redux-observable](https://redux-observable.js.org/) for this purposes for a while but it became more and more complicated to keep our code up-to-date, testable and maintainable with these two. The plan was to check some of the potential competitors of redux-observable and set an order along complexity, typesafety, number of dependencies and maintainability. We tried [redux-promise-middleware](https://www.npmjs.com/package/redux-promise-middleware), [redux-thunk](https://github.com/gaearon/redux-thunk), [redux-saga](https://github.com/redux-saga/redux-saga) and the potential of native es6 promises and at the first site [redux-promise-middleware](https://www.npmjs.com/package/redux-promise-middleware) was the one. After a while it came out that even though it fits our needs in many cases it doesn't do it in others. Sensenet repository is needed in all the levels of action creators and [redux-promise-middleware](https://www.npmjs.com/package/redux-promise-middleware) doesn't support using custom input params or any other ways to solve this issue for us. So we created our custom middleware based on [redux-promise-middleware](https://www.npmjs.com/package/redux-promise-middleware) with repository as possible input param and with adding some other minor things like changing the action delimiter and action suffixes. [sn-redux-promise-middleware](https://github.com/SenseNet/sn-redux-promise-middleware) is of course in the *@sensenet* scope and it became a dependency of sn-redux.

## Improving type safety, tests, coverage and code quality

One of the main purposes of replacing rxj was that some part of the code was and would have been always untestable and also the coverage could not have been improved above a certain level. Creating a custom middleware lets us reach every level of the code and this way we were able to maximaze the code coverage to 100%.

![Celebration](/img/posts/celebration.gif "Celebration")

Besides that number of tests and the code coverage was improved we set higher standards in linting rules of the project as well.

## Documentation update and clean-up

Huge part of the documentation became pretty outdated because of the numerous changes of the API, so it was clear that it need to be revisited and fixed. Since we've added linting rules to force us documenting public stuff, no undocumented code is allowed and the API docs of the current version are complete. [Docs are moved to sensenet's community site](https://community.sensenet.com/api/sn-redux/index.html) so you can discover it in depth. 

## Update sn-redux in your application

As I mentioned it above while we were updating our test projects like sn-dms-demo, we've made a list of issues and of course the possible solutions. If you have used sn-redux before and thinking of the upgrade, the following checklist makes you sure that it could be done with only a few changes.

#### - Update all the imports related to sn-client-js and sn-redux like

```ts
import { Reducers } from '@sensenet/redux'
```

#### - Remove rxjs imports
#### - Creating the repository instance like

```ts
import { Repository } from '@sensenet/client-core'

const repository %3D new Repository({
  repositoryUrl: 'https://mysite.com',
  requiredSelect: ['Id', 'Path', 'Name', 'Type', 'ParentId', 'Actions', 'Avatar'] as any,
})
```

#### - Use JwtService like

```ts
import { JwtService } from '@sensenet/authentication-jwt'

const jwt %3D new JwtService(repository)
```

#### - Way of creating and configuring a sensenet redux store has changed. You have to create a ```CreateStoreOptions``` object and use it as the only input param of ```createSensenetStore```

```ts
import { Reducers, Store } from '@sensenet/redux'

const options %3D {
  repository,
  rootReducer: myReducer,
} as Store.CreateStoreOptions

const store %3D Store.createSensenetStore(options)
```

#### - Replace your custom Epics creating async functions like:

```ts
export const userRegistration %3D (email: string, password: string) %3D> ({
    type: 'USER_REGISTRATION_REQUEST',
    email,
    password,
    async payload(repository: Repository) {
        const data %3D await repository.executeAction({
            name: 'RegisterUser', idOrPath: `/Root/IMS('Public')`, body: {
                email,
                password,
            }, method: 'POST',
        })
    },
})
```

#### - Action names were changed to Pascal case (e.g. UploadContent to uploadContent)
#### - Since the success and reject actions are handled in the background you cannot dispatch them manually.
#### - If you've created an Epic not for handling async operations but for subscribing on actions you have to subscribe separately after configuring the store. 

For example I've created a ```MessageBoxHandler``` in the [dms-demo](https://github.com/SenseNet/sn-dms-demo) to subscribe on the ```onContentDeleteFailed``` and ```onContentDeleted``` events and added this handler after the store creation like:

```ts
const store %3D Store.createSensenetStore(options)

const handler %3D new MessageBoxHandler(repository, store)
```

#### - action.response is changed to action.payload
Check your custom Reducers that are connected with built-in sn-redux actions.

#### - Some actions have a different order or number of arguments. Please check the API docs 

## What's next

Since the API is ready we can update our React controls package as well.

We also plan to update our command line tool to allow developers fetching their content types from CTDs but before we do that we want to improve the *client-side schema loading*.

Meanwhile we're working on independent components like the [Document viewer](https://github.com/SenseNet/sn-document-viewer-react), creating demo apps like [sn-dms-demo](https://github.com/SenseNet/sn-dms-demo) and trying to provide you more and more docs and tutorials on [sensenet community site](https://community.sensenet.com).

We are open and want to build a great community around sensenet so your opinion is super important to us. Please try, review and comment our work and help us make the world a better place! 😻

We've continued refactoring client side packages with [sn-redux](https://github.com/SenseNet/sn-redux). Similarly to [sn-client-js related new scoped packages](https://community.sensenet.com/blog/2018/02/21/scoped-packages), the changes were about removing dependence on rxjs, improving the API, review other dependencies and making some clean-ups.

2018-04-18-refactoring-snredux

Refactoring sensenet's redux library

We've refactored a lot of code to simplify our API, improve working with immutable objects and also did a strict review on our dependencies. I will summarize the reasons, the improvements and what has been changed.

## Why?

Long story short: our all-in-one *sn-client-js* has started to grow too fast. The development started to getting slower and harder. The package contained some well-separable parts (like querying, default content types or repository events) that could be easily extracted into separate packages. It had some parts (like the Repository and Content API) that we had to rethink and some parts (like internal modules or namespaces) that are no longer recommended to use.

### Immutable objects

Redux - as many other libraries nowadays - uses *shallow equality checking* for change detection and therefore it needs to work with [immutable data](https://redux.js.org/docs/faq/ImmutableData.html). Our Content and Repository API-s were not fully prepared to work with immutable objects: our rich-domain-inspired Content API had its own change detection mechanism. We had to rethink the concepts of the client side repository and content API implementation in terms of immutability.

### Internal modules and namespaces

We've packed a lot of things in **sn-client-js**: default content type and schema definitions, logics for querying on OData, authentication logics, etc... They were organized into *internal modules and namespaces*. This approach is less and less recommended, nowadays namespacing is even considered as [needless](https://www.typescriptlang.org/docs/handbook/namespaces-and-modules.html) by TypeScript. There were some modules (like the default Content Types) that were worth extracting into separate packages.

### The size of sn-client-js@^3.0.3 in numbers

Based on the generated Typedoc documentation, we have 205 classes, 13 enums, 7 interfaces in the 23 internal modules.

If you install sn-client-js into your NPM project, it will contain about 890 files and will take about 20MB of space.

If you clone and install the latest sn-client-js, you will have **275** folders in your *node_modules* folder and the whole package size is approx 160 MB.

The package contains about **~458** unit tests that isn't a problem itself: it takes less than roughly a second to complete. But with the full build process it takes **~20** seconds.

## The goals

We wanted to divide our overgrown client side packages - especially our *base* package, *sn-client-js* - into smaller, lightweight ones. NPM offers [package scoping](https://docs.npmjs.com/misc/scope), so we've decided to publish the new packages within a **@sensenet** scope.

We wanted some features - like repository events, mapping controls to schemas or even JWT authentication itself - to be fully optional.
We wanted to review if we can switch to some native APIs from external NPM libraries - for example in terms of RxJs and native promises with fetch API. We wanted to catch up with the industry standards in terms of immutability and standardize our linting settings.

We also wanted to take a look on our build, test and publish processes and - last but not least - the content of our NPM packages.

## The new packages
![NPM packages and dependencies](/img/posts/scoped-packages-dependencies.png "NPM packages and dependencies")

### [client-utils](https://www.npmjs.com/package/@sensenet/client-utils)

This package contains some generic utilities - like helpers for disposable objects, a retrier, a method tracer and a simple value observer implementation - and *without any sensenet dependencies*, so it can be used in any project.

### [query](https://www.npmjs.com/package/@sensenet/query)

If you want to create typesafe content queries you can do that with this package. It has a fluent API to create a query from a generic type argument.

### [default-content-types](https://www.npmjs.com/package/@sensenet/default-content-types)

We store the default generated content types, schema definitions, enums, etc... in this package. This package (unlike the others) doesn't contain any unit tests as it doesn't contain application logic - it can be used as a content type / schema library.

### [client-core](https://www.npmjs.com/package/@sensenet/client-core)

The *core* logic sits in this package, if you want to interact with sensenet its a good starting point to install it.
It contains the refactored *Repository* object itself, you can load / modify / delete content and execute custom action from there.
It also contains some predefined security and versioning related actions, response models, interfaces and abstracts.

### [authentication-jwt](https://www.npmjs.com/package/@sensenet/authentication-jwt)

If you install the [@sensenet/client-core](https://www.npmjs.com/package/@sensenet/client-core) package, it bypasses authentication by default. That means if you need JWT authentication, you have to install this package as well and configure it on your *repository* instance.

### [authentication-google](https://www.npmjs.com/package/@sensenet/authentication-google)

It contains the Google Oauth authentication implementation. This package depends on JWT, but it's fully optional. 

### [control-mapper](https://www.npmjs.com/package/@sensenet/control-mapper)

It contains an utility that helps to map third party controls to generated sensenet schemas. It's optional, but used by our control packages.

### [repository-events](https://www.npmjs.com/package/@sensenet/repository-events)

If you want to listen to specific repository events - like a content change - you can use this package. This is also optional, but we use it in [@sensenet/controls-aurelia](https://www.npmjs.com/package/@sensenet/controls-aurelia)

### [@sensenet/controls-aurelia](https://www.npmjs.com/package/@sensenet/controls-aurelia)

Our Aurelia control package has been refactored. The main change here is that it uses packages from the @sensenet scope as dependencies.

## Concept changes

### Removed content API, cleaned up Repository API

The main change is that the Content API itself has been removed. Most of its responsibilities has been taken by the Repository - in the most cases this means that e.g. ``myContent.checkout();`` has been moved to ``repository.versioning.checkOut(myContent.Id);``.

Another breaking change is that in the future content creation and updates will be possible only on *repository instances* via the exposed **post/patch/put** methods. That means that ``myContent.save()`` will be changed to ``repository.patch({idOrPath: myContent.Id, content: myContent})``.

### Promises, fetch and disposables

In sn-client-js we used RxJs observables for asynchronous operations. We've removed the whole RxJs library from our dependencies and switched to native ES6 promises and to the native **fetch** method. That means that you can use now the [async / await](https://hackernoon.com/6-reasons-why-javascripts-async-await-blows-promises-away-tutorial-c7ec10518dd9) syntax with sensenet calls.

There are a few observables like the current user, the login state or the repository events, they use our own simplified [observable](https://github.com/SenseNet/sn-client-utils) implementation. The difference is that these observables are also *disposables* so if you want to stop receiving updates, you have to ``dispose()`` them.

### Less transformation

We've reviewed and removed a lots of transformations in terms of odata requests, that means you will have access to the original json object and you can transform it afterwards.

## Package optimizations

One of the main goals was that our new packages should be small and lightweight. We've started with a strict dependency review that included the indirect dependencies as well. We've started to change our scripts to NPM scripts from Gulp tasks earlier and now we didn't have any dependency on Gulp. As I've mentioned earlier we've switched to native promises and we could remove our dependency on RxJs that is a huge package itself.

We've used another package in our unit tests called *mocha-typescript* that enables unit test running with a nice decorator syntax - but it had [~59](http://npm.anvaka.com/#/view/2d/mocha-typescript) indirect dependencies, so we've also changed our unit tests to the plain mocha syntax.

Now most of our packages doesn't even have any external dependency that you *have to install*.

We've continued with reviewing our processes: We use [Typedoc](http://typedoc.org/) for API Docs generation - this is a great tool however also adds about [60](http://npm.anvaka.com/#/view/2d/typedoc) package as indirect dependency. We also use commitizen for GIT commit message formatting, but it means about [134](http://npm.anvaka.com/#/view/2d/commitizen) indirect dependencies. These two tools play an important role in our internal processes but not during development - therefore we've decided to remove them even from our *devDependencies* and install them as global NPM packages.

We've started to optimize our NPM package sizes next. We've removed the coverage reports - you can still check them on [Codecov](https://codecov.io/) - and the generated API Docs. They will be published into our [community site](https://community.sensenet.com/docs/) soon.

As the last step we've separated our **build** and **build:test** processes - the test artifacts will be compiled into a *temporary folder* and will be excluded from the NPM package and the **dist** folder will contain only that artifacts that the package uses.

The results: If you are using the scoped packages in your NPM project, the current version - with JWT, Google Oauth, the Repository events and the control mapper will - take **~2MB** of space (sn-client-js took nearly 20MB).

Most of our scoped packages **won't install any third party package**. The only exceptions will be that packages that will *rely* on a specific framework or library, like the *Aurelia-controls* or the Redux package.

If you are developing a scoped package and you install the *dev dependencies* as well it will take *less than a half of the size of sn-client-js* (~66 MB vs ~149 MB in size, ~7000 files vs ~20 000 files).

The full build and unit testing time has also been improved - from about ~20sec to ~5sec.

## Changes

As I mentioned earlier there are no internal namespaces in the scoped packages - therefore you can *import* exactly just the classes / methods that you will need. I've collected a some common examples.

### Creating a Repository

You can start installing the *core* package with the ``npm install @sensenet/client-core`` command and creating a repository:

```ts
import { Repository } from '@sensenet/client-core';

const repo %3D new Repository(
 {
 repositoryUrl: "https://my-sensenet7-instance.com",
 });
```

### Configuring JWT and Google OAuth

As JWT is an optional feature, you have to install the corresponding package with the ``npm install @sensenet/authentication-jwt`` and you have to configure it after repository creation in the following way:

```ts
import { JwtService } from "@sensenet/authentication-jwt"

const jwtService %3D new JwtService(repo);
```

Once you have JWT, you can set up Google Oauth easily after installing the package **@sensenet/authentication-jwt**:
```ts

import { addGoogleAuth, GoogleOauthProvider } from '@sensenet/authentication-google';

const googleAuthProvider: GoogleOauthProvider %3D addGoogleAuth(jwtService, {
 clientId: 'my-google-client-id',
})
```

### Loading a content

There are some major changes when it comes to content loading. The first one is that the packages use *promises*, as mentioned above, so from now on the operations can be *awaited*.

The second one is that we've eliminated many unnecessary data transformations, so you can work with the plain serialized data object from the response itself. This also means that you cannot use "instanceof"-type checks on these object, you can use the "Type" property at runtime and *generics* in TypeScript during development.

There are two methods - load and loadCollection - that can be used for loading single contents / one-to-one references and collections / one-to-many references.

```ts
const portalUsers %3D await repo.loadCollection<User>({
 path: "/Root/IMS/BuiltIn/Portal",
 oDataOptions: { /** additional options */ },
});
console.log("Count: ", portalUsers.d.__count);
console.log("Users: ", portalUsers.d.results);
```

### Updates

There are also some breaking changes with the content creating / updating API: The POST/PUT/PATCH methods are now available directly on repository instances. You can also use TypeScript generics.

```ts
const response %3D await repository.patch<User>({
 idOrPath: "Root/Example/My_Content",
 content: {
 LoginName: "myNewLoginName",
 },
 oDataOptions: { /** additional options */ },
});
```

### Other actions

The bacth actions (copy, move and delete) are also available on repository instances and you can also find the *security* and *versioning* under the corresponding namespace.

If you have custom OData actions implemented, you can use the ``executeAction`` method as shown in the example above - or wrap them with strongly typed method calls like we did for the Security and Versioning related actions:

```ts
const response: Promise<TReturns> %3D repo.executeAction<TPostBody, TReturns>({
 name: "MyCustomAction",
 idOrPath: "Root/Example/Content",
 method: "POST", // or GET
 body: {
 { myCustomPostData: myCustomValue } as TPostBody,
 },
})
```

## Further goals

Although the scoped packages has been published, we have still some tasks remaining: We have to publish the API documentation to the community site and update our tutorials.

We've already started to update our Redux package, review its dependencies and improve the async operations - it will be also a scoped package. After that we can update our React controls package as well.

We also plan to update our command line tool to allow developers fetching their content types from CTDs but before we do that we want to improve the *client-side schema loading*.

We hope that sensenet development will be simpler and more fun than ever with the new packages. If you have any questions or thoughts don't hesitate to share with us :)

We've started 2018 with a huge package refactor: we have divided our base *sn-client-js* package into several smaller ones and published them within a *@sensenet* scope.

2018-02-21-scoped-packages

Scoped packages

Of course we continue improving the product but another important project is to build a stronger, larger, more active community and to provide useful materials for newcomers in the form of code samples, tutorials and videos.
We appreciate every feedback and we strongly recommend to report issues concerning the product or its components and send pull request in case you have any suggestion to improve sensenet 7. 
Our goal is to build the best development platform for our community, and for this, we need your help.

### Growing community
![Community Rocks](/img/posts/community-rocks.png "Community Rocks")

For growing the community we need some experienced and talented developers already working with sensenet. Fortunately we have many people like this in-house. We started a project where every developer needs to achieve some milestones by answering questions on [Stack Overflow](https://stackoverflow.com/questions/tagged/sensenet) and sending pull requests like bug fixes or product improvements on [GitHub](https://github.com/SenseNet).

For tracking the results and to check other's statuses achieving these goals we created an in-house website.
Here our developers can see every sensenet related open question on Stack Overflow and non-resolved issues reported on GitHub.
GitHub and Stack Overflow accounts are connected to this site, so we all have up to date info about our progress achieving these goals.

In the beginning of this new project we are collecting feedback from our developers and improving the system if required. The goal is to have a helpful and active community with strong in-house contributors who are the most experienced sensenet developers on Earth.


### DMS MVP

The [DMS MVP](https://github.com/SenseNet/sn-dms-demo) already introduced in our recent [post](/blog/2018/01/24/q4-results#dms-mvp) have a bright future as we will publish the package as a working solution as soon as possible so you'll be able to test and improve it by reporting issues or sending pull requests. We appreciate every feedback and suggestions.

### Control packages

As sensenet 7 could be a robust content repository for every one page app (like DMS MVP above), we created two collections of UI components and controls for sensenet written in our favourite JS frameworks, namely [ReactJS](https://github.com/SenseNet/sn-controls-react) and [Aurelia](https://github.com/SenseNet/sn-controls-aurelia).
In Q1 2018 we plan to publish a 1.0 version of these packages and provide some documentation as well so it will be easier for you to start working with SN7 using one of these frameworks.


### Refactor search module
![Needle in a haystack](/img/posts/needle-in-haystack.png "Needle in a haystack")

Search module refactor is also a high priority task for Q1. The two main missions in this topic are the following:
- Make a generalized layer for information retrieval operations (indexing and querying). This will decouple search operations from the underlying technology.
- Lucene Search service: create a standalone, separately deployable service based on the current Lucene indexing implementation. This is important in a cloud environment, where you cannot have a local index on the web server.


### Messaging and caching

As the current MSMQ messaging implementation is not feasible in the cloud, we will implement a more modern server-to-server communication architecture that will help operators use sensenet in an auto-scalable cloud environment.
Cloud compatibility is a must have feature these days, that's why we are working on solutions like Lucene search service mentioned above or the replacement of the MSMQ messaging, so sensenet could go to the cloud in the near future. 

### Training materials

As SN7 introduced a new era, our developers who are working with sensenet day by day, also need to learn some new skills to take advantage all the features of the product using modern programming languages.
These in-house trainings involve the following skills
- TypeScript, ES6+
- ReactJS, Redux, Aureliajs
- [sn-client-js](https://github.com/SenseNet/sn-client-js), [sn-redux](https://github.com/SenseNet/sn-redux) and other sn related frontend packages
- tools: testing, CI, documentation, linters

### Tutorials
![Tutorials](/img/posts/bookshelf.png "Tutorials")

Our plan is to provide more tutorials and guides to our community to help familiarizing with SN7.
We already have some useful stuff, so you'll be able to start working with sensenet whether you are an [MVC](/docs/tutorials/starting-out-with-mvc/) fan or you prefer using JavaScript frameworks like [React](/docs/tutorials/starting-out-with-reactjs/) or [Aurelia](/blog/2018/01/10/starting-out-with-aurelia).

These materials will be mostly in written format but video tutorials will be published as well, for example about the sensenet 7 install process.

### Scoped packages

Most of our components are available as npm packages like [sn-client-js](https://github.com/SenseNet/sn-client-js).
Introducing "sensenet" [scope](https://docs.npmjs.com/misc/scope) in our naming conventions is a must, so our packages will be well organized, and also because npm treats these grouped packages a bit differently than regular unscoped packages.

```
@sensenet/thisisthefuture
```

In the next few months we would like to make some optimizations on these packages as well. Split them into smaller ones if necessary and carry out a massive code decoupling and refactor. A strict review on our 3rd party dependencies and to allow client functions to work with immutable objects are also amongst our goal for the first quarter of 2018.



### New components
![Components](/img/posts/toy-pieces.png "Components")

SN7 stable release was a huge achievement for the team but we cannot stop here. Components available in previous versions of sensenet like preview generator, document viewer or adsync need some modifications to work flawlessly in the new SN7 environment. Our plan is to publish these updated components as soon as possible and work on new components as well, first the Azure Blob Provider.
When these components will be available, we can start thinking about the migration of current projects to sensenet 7, because all of the features (except some retiring ones) will be available in the new version.

Few weeks ago we published a [short overview](/blog/2018/01/24/q4-results) of Q4 last year's achievements and milestones like the sensenet 7 stable release.

2018-02-07-2018-Q1-goals

First quarter's product goals

When you build a site with sensenet, you have many options when it comes to choosing a technology. This post walks you through a few easy steps to create your first **Asp.Net MVC** app with sensenet 7.0.

2018-01-31-Getting-started-MVC

Getting started with sensenet using MVC

## sensenet 7 stable release

One of the biggest milestones of last year was [sensenet 7 stable release](https://community.sensenet.com/blog/2017/12/06/release-7.0-stable) back in december. With the new version, the core source code has not changed much, but SN7 introduced a new, [componentized era](https://community.sensenet.com/blog/2017/09/27/new-sn7-components), by slicing up the product to building blocks or components.
After four beta releases we introduced the stable sensenet 7 release. We are going to continuously publish patches for SN7 so you can already start working on new projects using the new version, we have your back.


## Componentization
![Componentization](/img/posts/componentization-wooden-toy.jpg "Componentization")

As mentioned before, SN7 is no more a huge monolithic piece of software, it is built up of different components which can be added to the core Services component based on your own needs.
Once this core layer, mother of all components is installed in your project, you can already start working on your solution but we have some really useful components to help you out.

- [Workflows](https://github.com/sensenet/sensenet/issues/76) are a great tool for building business processes involving content creation and response to human interactions (approving a document, completing a task or clicking on a link in a mail).

- [Notification](https://github.com/sensenet/sensenet/issues/77) is a feature for users who want to be informed about Content changes in the system. Users can subscribe to notifications on possible changes to Content items.

GitHub links:  
[Workflow component](https://github.com/SenseNet/sn-workflow)  
[Notification component](https://github.com/SenseNet/sn-notification)


## DMS MVP

We think the best way to develop and improve a product is by using it.
That's why we decided to create a [document management system MVP](https://github.com/SenseNet/sn-dms-demo) using sensenet 7 as content repository and write a one page app using React. Feel free to clone the solution, study the code or even use or improve it.

The feature set of the DMS MVP were the following:
- login
- registration
- basic document library
- basic document management functionalities (create, copy, move)
- upload


## IR Decoupling

We started working on re-architecting our [Information Retrieval](https://github.com/SenseNet/sensenet/issues/125) module that consists of two important features of an ECM solution: indexing and querying. Previously the exclusive tool used for this was Lucene.NET with a local index folder. That is a problem in a cloud environment where you cannot rely on having local indexes on the web server. So we decided to decouple Lucene-related indexing and querying operations from the main product and generalize the whole feature.

Now we are close to finalizing the first step: making the IR module replaceable. This will let us create a new search engine for cloud environments that will work as a service. Stay tuned for news on this very soon!


## Batch action improvements
![Batch action improvements](/img/posts/batch-action-flock.jpg "Batch action improvements")

We have done some improvements which will make your life better when copying, moving or deleting multiple files. From now, in case of failure, the process will return with detailed information about each problematic files, giving you some hint about the cause of the issue.
Use and test it, and feel free to give us feedback.

If you are interested in the development process, follow the link below to have more info about the changes and improvements.
https://github.com/SenseNet/sensenet/issues/147


## OAuth

OAuth 2.0 is the industry-standard protocol for authorization. In sensenet we use it as an extension to our JWT authentication to let users authenticate using well-known services (such as Google or Facebook). The benefit is that users are able to sign in to a sensenet application with a single click, without manual registration. Read the [blogpost](https://community.sensenet.com/blog/2017/12/20/first-oauth-implementation) to learn more.

Integrate [Google authentication]((https://github.com/SenseNet/sn-oauth-google)) to your own application following our [tutorial](https://github.com/SenseNet/sn-client-auth-google).
In the first iteration we only implemented Google Sign-in, but you can add other services (like Facebook). If you do so, please consider sharing it with the community so that others can use it too!

Last year was quite busy in Sense/Net. The main goal of the core team was to publish sensenet 7 stable release, but also lots of other improvements have been done concerning the product.
Let us summarize what we achieved in 2017!

2018-01-24-q4-results

What's happened with sensenet in Q4 last year

![man on the moon](/img/posts/man-on-the-moon.jpg, 'man on the moon')

Actually, this is not a big deal from a technical point of view: there were a few bug fixes, some interesting new features (like supporting *Google Sign-in*), but there is not much more in there than in previous releases.

But from the product's point of view - well, this is a *giant leap* forward.

## Ready to go
The ones who've been following our journey from *sensenet 6* to *sensenet 7* know that we did not actually change much in terms of source code. Of course we had to slice the whole thing into [components](https://community.sensenet.com/docs/sensenet-components/), but we tried to keep everything intact. This is why we think that you can safely go into production with this release - because the majority of the code is already in production on many sites with sensenet 6!

Another reason to let this into production is that from now on we will publish **patches**. That means you will not have to start from scratch in your production environment (which is of course not an option), but execute the patches published by us (or maybe 3rd party vendors who publish sensenet components).

> It is still advisable to work with a **clean database** workflow in your **development and test environment**. The best practice is to create a CI build that is able to re-create your whole site and database from scratch, including installing sensenet.

## Upgrades in the future
Until this point we published pre-release versions of the product on [nuget](https://www.nuget.org/packages?q%3Dsensenet) and on [GitHub](https://github.com/SenseNet/sensenet/releases) as well. We did not publish patches that would work as in-place upgrades on an existing sensenet installation.

> That changes now.

From now on we will assemble a proper **[SnAdmin](https://github.com/SenseNet/sn-admin) package** for every release we publish. Sometimes it will contain real content repository changes (e.g. a script that changes the db schema or added/modified content items), sometimes it will just bump the component version in the repo. 

When developers get the new version from nuget, they will have to execute an SnAdmin command (in the command line) with the patch. In some cases (very rarely) there may be some additional manual steps, but we will explain those in detail and we plan to avoid that if possible.

## Beta packages
Will we publish beta releases in the future? Of course! It helps our community a lot if we are able to show you what are we working on and try to collect feedback before publishing a stable release. Just do not push these into production, because that would involve manual patching in the future, which can be risky.

## Components with different versions
As sensenet is built from many [components](https://community.sensenet.com/docs/sensenet-components/), these components are released in a different pace. In some cases there will be version dependencies among components (e.g. one component's latest version cannot work without upgrading a different one), but we will state these prerequisites when releasing a component - and of course nuget packages will force those dependencies too.

## What's next?
The journey does not stop here of course! We have many features to add and architectural improvements to make (take a look at the post about our [frontend release](/blog/2017/11/29/sn-frontend-releases-in-november) for example).

![mountains](/img/posts/blue-mountains.jpg, 'mountains')

The next major release is planned to include the **Search infrastructure improvements** we have been working on in the last several months.

We also plan to modernize our **messaging backbone** to make it suitable for cloud installations (meaning replace good old *MSMQ* with a more modern service).

[Office Web Apps Server](https://technet.microsoft.com/en-us/library/jj219437.aspx) integration is also something we would very much like to add to our feature stack.

Stay tuned for releases in the near future and please [contact us](https://community.sensenet.com/contact/) if we can help you with anything!

Welcome to the [stable release](https://github.com/SenseNet/sensenet/releases) of sensenet 7.0!

2017-12-06-release-7.0-stable

sensenet 7 stable release is out

## sn-client-js 3.0.0

[sn-client-js](https://github.com/SenseNet/sn-client-js) is the core - and a main entry point - of our client side packages. It contains logic about interacting with a Repository, authentication, querying and has the built-in content types bundled.

### Cleaning up the concepts of a Content Type

Typescript Content Types can be generated from the sensenet Backend and are useful if you want to write *strongly typed Typescript* code. In the previous releases, Content Types was inherited from the Content class (which is a rich domain model driven representation of a Content instance). For Example, the User inheritance looked like:

Content **&rarr;** GenericContent **&rarr;** User

Now we've extracted our *Content* (now *ContentInternal*) class from the inheritance chain and created a Type Alias called 'Content<T>' - this one is an Union Type of *ContentInternal* and the specified Type. There are some of the many benefits of this change
 - If you are using plain JavaScript, you don't even have to care about Content Types (except when creating a Content)
 - We could remove *all* logics from the generated Content Type Definitions. That means roughly 1000 lines of code :)
 - Using your own custom Content Types will be much easier. You only have to define a new Typescript class that implements IContent and you can use it

 ![Using a custom Content Type cannot be more simple](/img/posts/sn-client-300-custom-content-types.gif "Using a custom Content Type cannot be more simple")


### Repository bound schemas

ContentTypes and Schemas both describe content. At the moment Schemas are used for dynamic form generation and validation. Schemas - unlike ContentTypes - can change at runtime. Right after you change a Content Type Definition (e.g. add a new required field in the old Explore, or maybe in one of the future release of our admin GUI ;)) you will expect that the next content you create will pick up the change.
At the moment Schemas are generated as well, but from now on they are used only as *defaults*. Repository instances have their own *Schema stores* and their content can be *replaced*. We plan to add a live Schema reload feature in an upcoming release.

### Upload

We've added the chunked upload feature in version 2.5.0, now we improved it. We have three endpoints for Upload. With *repository.UploadFile()* you can upload a simple File object from a form or Drop event, with *repository.UploadTextAsFile()* you can save a string as a binary and finally *repository.UploadFromDropEvent()* lets you upload a whole file list or subtree with directories from a simple Drop event. Upload event works with *rx/js observables*, so it's easy to track the upload progress info based on the finished chunks.
Upload options has been extended with additional OData parameters in this release. They are useful if you want to specify fields to select or expand when the Upload finishes, so you don't have to reload the File content manually.

### Batch actions

Batch actions (copy, move and delete) have been improved on both back- and frontend. Now the client will receive a verbose response - per operation - and can trigger exactly the same repository events as for single operations. Let's take a look at the example *batch copy* operation response.
```json
{
 "d": {
 "__count": 3,
 "results": [
 { "Id": 101, "Path": "Root/Workspace/DocLib", "Name": "a" }
 { "Id": 102, "Path": "Root/Workspace/DocLib", "Name": "b" }
 ],
 "errors": [{
 "content": { "Id": 103, "Path": "Root/Workspace/DocLib", "Name": "C" },
 "error": {
 "code": "NotSpecified",
 "exceptiontype": "Exception",
 "message": {
 "lang": "en-us",
 "value": "Error message value"
 },
 "innererror": {
 "trace": "InnerError Trace value"
 }
 }
 }]
 }
}
```
The operation above will fire two **repository.Events.OnContentCreated** events and an additional **repository.Events.OnContentCreateFailed** for a single HTTP request.

But what can you do with batch operations and [repository events](/api/sn-client-js/classes/repository.repositoryeventhub.html)?

Imagine some separate components (e.g. a *tree*, a *content list* and a *breadcrumbs*, like a file explorer) attached to the same repository and some batch move / delete / copy operations. Synchronizing content can be hard. You have to avoid additional web requests and component reinits but update them with the changes - that's where repository events come handy. You can load the component data once and *subscribe* to an event inside your component. Once it's done you can handle changes incrementally - without additional requests or reloads:

```typescript

// an array to store the actual subscriptions
private Subscriptions: Subscription[] %3D [];

// once the component is attached, load it's data once then update it incrementally
async attached(){
 await this.LoadInitialData();
 const events %3D this.Repository.Events;
 this.Subscriptions.push(this.events.OnContentCreated.subscribe(created %3D> this.handleContentCreated(created)));
 this.Subscriptions.push(this.events.OnContentDeleted.subscribe(deleted %3D> this.handleContentDeleted(deleted)));
 this.Subscriptions.push(this.events.OnContentModified.subscribe(modified %3D> this.handleContentModified(modified)));
 this.Subscriptions.push(this.events.OnContentMoved.subscribe(move %3D> this.handleContentMoved(move)));
}

// ...and don't forget to clean up :)
detached() {
 this.Subscriptions.forEach(subscription %3D> {
 subscription.unsubscribe();
 });
 this.Subscriptions %3D [];
}
```

![A batch move example with a tree and a list](/img/posts/sn-client-300-batchmove.gif "A batch move example with a tree and a list")

### OAuth

We've added OAuth provider support for the JWT Authentication service. This means that you can implement and add your own OAuth provider - just like we did it in [sn-client-auth-google](https://github.com/SenseNet/sn-client-auth-google) 

## sn-client-auth-google 1.0.0

This package is our first official client-side OAuth provider. It requires sensenet ^7.0.0 with an installed SN7 [OAuth provider](https://github.com/SenseNet/sn-oauth-google) and a [Google API Console project](https://developers.google.com/identity/sign-in/web/devconsole-project). You can use it with or without the official [Google Platform Library](https://developers.google.com/identity/sign-in/web/sign-in) or any third party component that can retrieve an *id_token*.

We've focused on keeping this library straightforward and easy-to-use, hopefully you can integrate it within a few minutes - after checking an example in the [readme](https://github.com/SenseNet/sn-client-auth-google).
![Simple and straightforward OAuth login with sensenet and Google](/img/posts/sn-client-300-google-oauth2.gif "Simple and straightforward OAuth login with sensenet and Google")


## sn-redux 3.4.0

[sn-redux](https://github.com/SenseNet/sn-redux) always keeps an eye on [sn-client-js](https://github.com/SenseNet/sn-client-js), we're working mostly in parallel and this is how it happened this time. Learn how the new features were added and what and how you can achieve with them.

### Upload

There're three new actions to handle the upload related stuff. One for an upload request (can only handle one file at once), one for handling if a file was uploaded successfully and one for the upload failure. The upload functionality is implemented in the related reducers too, so if a new file was uploaded, its id is added to the ```ids``` array and the ```entities``` object will contain the new content. Of course there's a new [redux-observable](https://redux-observable.js.org/) epic handling the ajax request in the background, so to have the upload functionality you simply have to call the upload action:

```typescript
Actions.UploadRequest(content, file)
```

Param ```content``` is the parent content object and ```file``` is the file that should be uploaded.

Learn more about upload in sn-redux in the [API references](https://www.sensenet.com/Root/Sites/sensenet.com/documentation/sn-redux/modules/_actions_.actions.html#uploadrequest). 

### Batch actions

From now on batch operations are also supported in [sn-redux](https://github.com/SenseNet/sn-redux) with three new actions apiece for handling requests, operation successes and failures. Because batch operations' responses could be mixed (some content could be uploaded and some could not) a new reducer called ```batchResponses``` is added to hold the custom response and the error. At the background three new epics handle the processes. 

Learn more about the batch operations in [sn-redux](https://github.com/SenseNet/sn-redux) in the [API references](https://www.sensenet.com/Root/Sites/sensenet.com/documentation/sn-redux/index.html). 

### OAuth

Since the needed provider was ready both on the backend and in sn-client-js it was a must to add an action to handle login (and registration) with Google account in sn-redux too. However the after-login process is the same a new epic called ```userLoginGoogleEpic``` is created. This new epic is subscribed to the new login request action but if it was responded successfully or if it was failed it dispatches the same actions that are used in the simple login process. 

## What's next?

![Got stuff to do, can't talk now](/img/posts/busy.gif, `Got stuff to do, can't talk now`)

Let's see in a few words what is in our backlog for the winter:

#### Scoped npm packages
As [sn-client-js](https://github.com/SenseNet/sn-client-js) started to grow too fast it will be a good idea to divide it into multiple packages. We should change our naming conventions with our NPM packages and introduce package scoping for @sensenet specific packages just like [@Material](https://github.com/material), [@angular](https://github.com/angular), [@aurelia](https://github.com/aurelia) or [@ReactiveX](https://github.com/reactivex) did it.
#### ContentTypes vs. Schemas
Since ```ContentTypes``` and ```Schemas``` as auto-generated classes are bundled together and tightly coupled with the ```Repository``` object, we cannot extend or add content types from different packages (sensenet Services, Webpages, etc). So we should distribute ContentTypes in a separate package in the future to allow adding Content types and Schemas without changing [sn-client-js](https://github.com/SenseNet/sn-client-js).
#### CTD improvements 
Sensenet's Content Type Definitions are awesome but they need a facelift from time to time. This time it means some major improvements like adding solutions for field grouping, ordering and some changes around Icon property to handle font-icon libraries like [Material icons](https://material.io/icons/) or [Font awesome](http://fontawesome.io/)
#### Localization
String resources were enable on the client-side through sensenet's built-in bundling and dependency handling mechanism. Since we build separate applications with communicating through OData We have to figure out how localized string resources can be distributed from sensenet to the client.

Busy weeks behind us at the frontend division. New features on the backend and our in-progress DMS MVP generated tons of tasks and gave us many improvement points. We've released all these new stuff, so we can lay back a bit and sum up what's done.

2017-11-29-sn-frontend-releases-in-november

Autumn happenings in sensenet frontend-ville

Most of them were integration tests, involving multiple layers of the product, and as such, in many cases they required a fully installed sensenet database in place.

That is not how a modern test environment should work because of many reasons, mainly speed, maintainability, flexibility.

> So we started over.

In the core repository (that contains the main component, [sensenet Services](https://github.com/SenseNet/sensenet)) we started small. Added a few real unit tests (and moved some from the old test project) that covered only a certain class or method and did not require the whole repository to run.

After that we started investigating the possibility of writing new unit tests for modules that needed the repository - but without actually starting it. We realised that it would require a thremendous amount of refactoring to make the codebase 100% unit test friendly with classes that support dependency injection in a natural way. It would take too much time and break so many existing apis that it was not an option.

![Testing an ECM product](/img/posts/inmemory_database.jpg, 'Testing an ECM product')

## A whole database in memory
In sensenet you cannot load a content or execute a query without a running index and an accessible database - and this is somewhat important in case of a system that is designed around content and queries :).

> Even if an API does not indicate a content operation, it may involve accessing and modifying data in the background.

We started to experiment with simulating the database in memory and implementing load and save operations on top of that. It turned out that [@kavics](https://github.com/kavics) was able to construct an in-memory db in just a few days. The trick was that it was not a fully operational data provider - he just implemented the parts that were essential for covering the test scenarios we needed.

## Providers, providers, providers
In case of sensenet practically everything happens in the context of a "running repository". You cannot do much before all the managers, services and providers are started properly. So the next problem to solve was to be able to replace these real-life providers with mock ones so that the tests can concentrate on a single feature. Luckily most of these providers were already replaceable, it was just hidden in many different parts of the api.

We created a *Providers* API for bringing all these replaceable parts together. This is a gradual process, we will bring old and new features under this umbrella as needed. We also extended the **repository start process** by letting developers **inject** their own provider implementations instead of using the configured ones.

```csharp
var dbProvider %3D new InMemoryDataProvider();
var securityDbProvider %3D new MemoryDataProvider(DatabaseStorage.CreateEmpty());
var searchEngine %3D new InMemorySearchEngine();
var accessProvider %3D new DesktopAccessProvider();

var repoBuilder %3D new RepositoryBuilder()
    .UseDataProvider(dbProvider)
    .UseSecurityDataProvider(securityDbProvider)
    .UseSearchEngine(searchEngine)
    .UseAccessProvider(accessProvider)
    .StartWorkflowEngine(false);

using (var repo %3D Repository.Start(repoBuilder))
{
    // Load and save content here - then check the results.
}
```

The sample above is taken from one of the test methods. Many of them start a repository instance of their own and make changes in those sandboxes instead of a real database. This makes initialization and execution *100 times faster* than before. It also clears the way for future improvements.

## What's next?
Currently you cannot do *everything* using this method, for example binary handling is not implemented yet in the in-memory db. When during testing we encounter such a blocker issue, we will add the missing providers to this api gradually.

The current architecture still has some *static* elements that prevent us from running tests *in parallel* - so they are executed sequentially for now, otherwise tests would interfere in each others' environment. We plan to make every provider and module accessible through *instances* that can co-exist, so we can execute tests in multiple independent environments.

In the previous version of sensenet we had many tests, 1400+. They covered most of the codebase, but unfortunately only some of them were real unit tests.

2017-10-27-in-memory-testing

In-memory testing in sensenet

## What is a digital workplace?

Services provided by the industry no longer influence only free time activities. Different software, enabling work on-the-go developed for end users are widely used by multinational corporations and small businesses as well.
The [digital workplace](https://www.sensenet.com/for-customers/use-cases/digital-workplace) does not exist in physical form - it is central workspace to which the members can connect to from any part of the world. This is usually the result of several workstations connected through servers, however the work group members can access the network even by using their home computers or smart phones. Thus the digital workplace primarily consists of people, hardware, software and online work processes. 

## Benefits of going digital

The solution can be used in almost any industry thanks to the simple, fast and secure document handling, content services and development platforms. Not to mention the significant improvement of the work experience.

It can help education as well thanks to the online platforms provided by the system that allows teachers and students to connect to it anywhere and anytime. The online workplace makes sharing school knowledge, talent promotion and the related administration easy.

A digital workplace brings significant results in the area of financial services as well. This opportunity entails the modernizing of the IT infrastructure of a given financial business, sharing confidential data securely and handling legal restrictions, obligations and license management as well.

A digital workplace can reduce the costs of healthcare, the savings created thus can be used to improve the quality of healthcare. The software available on desktop and mobile devices as well can unify and make patient information easily accessible and securely stored for the doctor and patient as well.

Many well-known companies worldwide, like Google, Microsoft or the British London Capital Group also enjoy the advantages provided by the digital workplace.

![Improvement](/img/posts/what-marketing-wont-tellyou-improvement.jpg, 'improvement')

## Are there areas where it cannot be applied?

The dark side of the digital workplace is not related to being compatible with certain industries but with the social changes caused by this method. [Paul Miller](https://www.amazon.com/Digital-Workplace-Technology-Liberating-Work/dp/1457510960) in his book, *The Digital Workplace: How Technology is Liberating Work,* discusses how the digital workplace can cause addiction that can damage our social life.

According to Miller, if anybody can work from anywhere at any time the work is going to take up more and more of our everyday life, as we see work as less of a burden. This can easily lead to the development of workaholism which can have severe symptoms. When using digital workplace application, it is necessary to pay attention to leave ourselves enough free time for recreation. We should not neglect our friends and family.

![Workaholic](/img/posts/what-marketing-wont-tellyou-workaholic.jpg, 'workaholic')

## How is it more effective: a distinct body of systems or one system that solves everything?

You certainly had the experience that the more software you use to conduct a project, the harder it is to control the work process. As in such a case you need to divide your attention, which on the long term is not effective. Not to mention how annoying it is when a project cannot be finished due to some project file compatibility problems.

With [sensenet](https://www.sensenet.com), which is an open source .Net CSP, you can build your own digital workplace according to your needs.

Our consumer habits and everyday way of life went through significant changes during the last several decades. The most prominent development happened in the field of IT.

2017-10-18-Digital-workspace-the-reality-and-what-marketing-wont-tell-you

Digital workplace

![ci_tools_k2](/img/posts/ci_tools_k2.gif, 'ci tools')


### Before you dive in

 If you want to be sure that your merge won't be causing any trouble there are several tasks to do - like creating a sandbox, building and testing on multiple environments, comparing code coverage results, etc... That's a soul grinding work for a developer - and should be automatized.

We use GitHub nowadays and we work with pull requests. These pull requests are playing a key role in the terms of CI tooling, most of the tools are working with [pull request status checks](https://developer.github.com/v3/repos/statuses/). This means when you create a pull request, the tools will check if the branch is up to date, it can be built, the tests are OK, etc...

### Front-end and Node.JS tools

We have several NPM packages and the goal is the same. We want to know if the changeset *can be merged safely*. We want to build, test and run some static code analysis. In more detail we want a sandbox environment with Node.JS and the latest available dependencies installed, we want our *typescript* sources and tests to be compiled to *js*, run our *mocha/jest* unit tests and process the reported coverage from *nyc*.

#### Travis

[Travis](https://travis-ci.org/) is the most important CI tool we use. You will need only a github account with a repository, a working codebase and a small configuration script. It's responsible for creating a sandboxed environment, downloading the codebase, install dependencies, build, run the tests and report the coverage. A build can contain multiple *jobs*, that means you can test your code in multiple environments. We're testing our packages on Node.js 6 (LTS), 7 and 8 in a *[trusty](https://docs.travis-ci.com/user/reference/trusty/)* environment. 

#### Keeping things green

If I had to choose two CI tools, it would be Travis and [GreenKeeper](https://greenkeeper.io/). Greenkeeper helps to avoid the *dependency hell*. Really. It scans the NPM repository and if a new version of one of your project dependencies is published, it will create a feature branch for that and runs the other CI tools. If the new version is *covered by your version range* and the checks fails, it will raise an issue, otherwise it just deletes the branch. If the new version is not covered but the tests are OK, it will create a *pull request* and you will be sure that the dependency won't break your build. Just take a look at the screenshot from this morning and think about it if you had to do it manually :) 
![ci_tools_greenkeeper](/img/posts/ci_tools_greenkeeper.png)


#### Covering code

We use [Codecov](https://codecov.io/) to measure our code coverage rate and check it per pull request. You can monitor coverage historically, compare between branches, even browse in annotated files. It's clean, simple, and it's easy to use with Travis.

#### Codacy

[Codacy](https://www.codacy.com) is a highly customizable code analyzer tool that can analyze your source code in terms of compatibility, security, unreachable code loops and code style.

### Backend - Visual Studio Team Services

[VSTS](https://www.visualstudio.com/team-services/) is the de facto standard for automatized builds and CI/DI with .NET. It can be used for *almost* all of the scenarios above, and not *just* for .NET. At the moment we are using it mostly for automatized web deployment and sandbox environment creation.

CI means you have to merge small changes continuously instead of working with large diffs at the end of the development cycle.

2017-10-11-CI-Tools-We-Use

CI Tools we use

Although IT personnel might be convinced of the necessity to keep up with technology and embrace the 21st Century, C-level decision makers might not always share their view and might be reluctant to vote for a costly change. To tell the truth, there are a number of other factors that cannot be expressed in sheer numbers that would bring invaluable benefit to board, investors, staff and clients as well.

Here are some of the hidden benefits.

**Streamlining**. If you want to use your digital workplace to its best advantage, you need to reconsider and optimize your processes. This means redesigning workflows, identifying and removing unnecessary steps or entire processes, resolving issues that cause productivity bottlenecks – and automating all that is possible. At the end of this process it might turn out that a considerable amount of valuable human work time is freed up to do more of the creative object.

**User experience**. A good digital workplace is tailored to the needs of its users, and not the users are required to bend around the (in)capabilities of just another new environment. If user experience is a top priority right from the beginning of the design phase, it will naturally result in happy users. And a happy employee is a more productive employee. To enhance user experience you need simple applications with intuitive interfaces that provide exactly the data necessary for the completion of the task the employee is required to complete.

![value_of_dw_userexp](/img/posts/value_of_dw_userexp.jpg, 'value of digital workplace user')

**Cross-platform**. A well-designed digital workplace enables user access from various devices, such as PCs, notebooks, tablets and mobiles. Can you imagine a situation when an employee has an urgent task to finish, her workday is already over and at the same time, has family or other commitments as well? A lifelike situation, isn’t it? Instead of being bound to the device located in the office, with a digital workplace solution this employee can finish the task on-the-go from a mobile device, or later from home. This means less stress and less stress means more relaxed and thus more productive employees. But this is not the only advantage of the cross-platform design. Lengthy travel times of business trips can be turned into productive time and field results can be entered into the system and made available to everyone right away.

**Data access**. If all data are stored digitally, they are easily searchable, shareable and quickly available anywhere, anytime, to anyone (depending on access privileges, of course). In a digital workplace data is created digitally – meaning that you always have access to the most recent data right away. This has clear advantages in decision making, when using outdated information might lead to dangerous, even business-critical results. But the advantages don’t stop here. If you have digital data, it means you have a digital archive as well. This eliminates the need to store paper copies, that makes make your business considerably cheaper, leaner and swifter, not to mention more sustainable and eco-friendly.

![value_of_dw_accessdata](/img/posts/value_of_dw_accessdata.jpg, 'access data')

**Compliance**. The new General Data Protection Regulation (GDPR) to enter into force on 25 May 2018 imposes strict privacy requirements on companies that handle personal data of EU citizens. With a digital workplace it is easy to comply with the new requirements – without it, well, almost impossible. Companies failing to comply might expect serious fines up to €20 million or 4% of their global revenue.

If you have been only playing with the idea of going digital it might very well be time to take action. If you have not yet considered these options, there’s one more aspect to consider: competition. Think of your most serious competitors and imagine they opt for the digital workplace. Do you want them to reap the fruits of the competitive edge going digital offers them, while you struggle on with all your paperwork? Take your choice and [contact us](https://www.sensenet.com/contact)!

Digital workplace (the modern intranet) is a phenomenon that has been lingering around for some time, yet many enterprises are still hesitant to move to digital – especially if the main focus is on the financial aspect.

2017-10-04-The-value-of-a-digital-workplace

The value of a digital workplace

You might be thinking "Okay, you tore the whole thing to pieces, but how the hell does it all fit together?" Fear not.

I’ll try and break down these components to you, so when you accidentally hop on to our github enterprise page, you won’t feel lost in the forest of repositories.

*[[DISCLAIMER: I am not coming up with all this all by myself. People smarter than me, have already written a great description about this [here](http://community.sensenet.com/docs/sensenet-components/). So if you don't like my style, by all means, hop over there and read everything you can find.]]*

If you're still here, fasten your seatbelts. It's going to be a long ride. So what's lurking under the SenseNet enterprise in GitHub?

## The Core

*The essentials. The alpha, and the omega. What you need to have a powerful content management platform up and running on your premises.*

[**SenseNet/sensenet**](https://github.com/SenseNet/sensenet)

Current NuGet package: [![NuGet](https://img.shields.io/nuget/v/SenseNet.Services.Install.svg)](https://www.nuget.org/packages/SenseNet.Services.Install)

At the very core of sensenet, there’s Sensenet Services. Services is the "Mother of All Components": you'll need it, if you want to do anything with sensenet, for it is the heart of the platform.

It contains:

- The main Content Repository and dynamic content type system
- A set of built-in basic content types (File, Folder Workspace, ContentList/DocumentLibrary)
- Indexing and Search
- Security
- **SenseNet/sn-admin**
  - This handy tool can be your best friend when developing on sensenet. Be sure to get acquainted with each other.
- **SenseNet/sn-tools**
  - When we face something more than once, it is nice to have a solution at hand the next time we encounter it. We collect our little tools in this repository.

But no UI, whatsoever. You can access the Content Repository inside Services through well defined - you guessed it - services/service entry points, such as the REST API, or WebDav. You can even use the javascript or the .NET client library, which are wrappers for the OData layer.

> For detailed install steps please follow [this link](http://community.sensenet.com/docs/install-sn-from-nuget/).

## Extensions

*Everything that makes your life better. Content types, we built for you. Prepackaged business logic in breadcrumbs, with mayo.* 

![Put it all together!](/img/posts/wrenches.jpg, 'wrenches')

[**SenseNet/WebPages**](https://github.com/SenseNet/sn-webpages)

Current NuGet package: [![NuGet](https://img.shields.io/nuget/v/SenseNet.WebPages.Install.svg)](https://www.nuget.org/packages/SenseNet.WebPages.Install)

WebPages is our good old UI component. When you install it on top of Services, you get a login page and the Content Explorer out of the box. You can build your own pages using the app model and our built-in portlets. Everything you'll find here is built with [ASP.NET](http://ASP.NET) WebForms.

To summarize, when you install WebPages, you'll have:

- The Services component (it's a requirement in the NuGet package)
- The Content Explorer
- A Login page
- Our Built-in Portlets

> For detailed install steps please follow [this link](http://community.sensenet.com/docs/install-webpages-from-nuget/).

[**SenseNet/Workspaces**](https://github.com/SenseNet/sn-workspaces)

Current NuGet package: [![NuGet](https://img.shields.io/nuget/v/SenseNet.Workspaces.Install.svg)](https://www.nuget.org/packages/SenseNet.Workspaces.Install)

Workspaces is a functional component for sensenet, it contains predefined content types for workspaces, you can use for various scenarios. If you only have Services installed (because for whatever reason you don't want to use WebPages or build your UI using [ASP.NET](http://ASP.NET) WebForms), you'll only get the workspace types. If, however, you have WebPages, you'll also get the related content templates and the whole UI package for Workspaces - build entirely in [ASP.NET](http://ASP.NET) WebForms.

> For detailed install steps, please check [this article](http://community.sensenet.com/docs/install-workspaces-from-nuget/).

[**SenseNet/Workflow**](https://github.com/SenseNet/sn-workflow)

Current NuGet package: [![NuGet](https://img.shields.io/nuget/v/SenseNet.Workflow.Install.svg)](https://www.nuget.org/packages/SenseNet.Workflow.Install)

This component integrates the powerful Windows Workflow Foundation into your sensenet. You can use it to build content driven workflows, such as the built-in Approval workflow.

If you want to build complex business scenarios and processes, Workflow is your go-to component.

[**SenseNet/sn-notification**](https://github.com/SenseNet/sn-notification)

Current NuGet package: [![NuGet](https://img.shields.io/nuget/v/SenseNet.Notification.Install.svg)](https://www.nuget.org/packages/SenseNet.Notification.Install)

Notifications lets your users subscribe to content changes in the Repository. The notifications are sent via e-mail either in bulk, or immediately. 

[**SenseNet/sn-taskmanagement**](https://github.com/SenseNet/sn-taskmanagement)

Current NuGet package: [![NuGet](https://img.shields.io/nuget/v/SenseNet.TaskManagement.Core.svg)](https://www.nuget.org/packages/SenseNet.TaskManagement.Core)

Task manager is a component you need to install completely separately. It's for managing long-running background tasks, such as preview generation. But don't let us set limits for your creativity, the task manager is a powerful tool to run a bunch of tasks in the background on a separate machine. 

Make sure you read the documentation for Task Management and discover it's full power.

## Client libraries

*Manipulate the Content Repository with the magic of client libraries. Build Single Page Applications, compelling UI's, or WPF desktop apps, all powered with sensenet! Take your pick.*

![Serve the client y'all!](/img/posts/serve-the-client-delish.jpg)

[**SenseNet/client-js**](https://github.com/SenseNet/sn-client-js)

Current npm package: [![NPM version](https://img.shields.io/npm/v/sn-client-js.svg?style%3Dflat)](https://www.npmjs.com/package/sn-client-js)

This Javascript (it's really Typescript, "but who counts" nowadays) library lets you work with the Content Repository by providing a Javascript client API for the main content operations.

Since we're talking about a Javascript library, instead of NuGet, you can install it from npm. Once you have a sensenet Services running somewhere, set up CORS and you're ready to start developing a Single Page Application for example.

There are several related packages that are in development and that will let you build applications in an even more productive fashion. These are:

- [sn-controls-aurelia](https://github.com/SenseNet/sn-controls-aurelia)
- [sn-controls-react](https://github.com/SenseNet/sn-controls-react)
- [sn-redux](https://github.com/SenseNet/sn-redux)

The first library contains sensenet UI controls implemented in Aurelia. The second does the same in React, with the exception that our React controls use Redux for a centralized state store, while our Aurelia controls don't. All of these libraries have the prerequisite of installing sn-client-js.

[**SenseNet/sn-client-dotnet**](https://github.com/SenseNet/sn-client-dotnet)

Current NuGet package: [![NuGet](https://img.shields.io/nuget/v/SenseNet.Client.svg)](https://www.nuget.org/packages/SenseNet.Client)

If you fancy using the Content Repository from your .NET application, you can easily do that using the .NET Client for sensenet. The library connects to the REST API and wraps it into a neat C# API. Use it any way you can think of (we think you could build nice WPF apps with it for example)!

If you have *any* questions, or feedback, talk to us. You can chat with us on [Gitter](http://gitter.im/SenseNet/sensenet), or send us [e-mails](http://hello%5Bat%5Dsensenet%5Bdot%5Dcom), like in the medieval times.

It's been a long year, but we're nearing the end of the componentization project for sensenet. What you could see, was a bunch of git repositories, NuGet and npm packages popping up now and again, but you may not be sure what they really does.

2017-09-27-new-sn7-components

Entering the new era - The componentized SN7

In the last few months I've read a couple of posts about the Redux store of Twitter and I thought if it was interesting to dig into their state tree it will be useful to write an article like this about sensenet's too. [Dissecting Twitter's Redux Store](https://medium.com/statuscode/dissecting-twitters-redux-store-d7280b62c6b1),  [Diving Deeper into Twitter’s Redux Store: Adventures in Minified Vendor Javascript](https://medium.com/@nuncamind/diving-deeper-into-twitters-redux-store-adventures-in-minified-vendor-javascript-67fbac5dc219) and other posts in this topic were not only guiding us analyzing sensenet's Redux store the same way in a similar post, but also helped us to figure out how a state tree in a content-heavy application could be built-up, and how we should structure data in our next DMS MVP's Redux store.

To be honest we had a Redux store before, it was the basis of couple of Todo apps that we've made with different frameworks to try out sensenet 7's Javascript Client and the API. But these apps were (and are) only prototypes with reduced functionality and they required only a basic state tree with less data and actions. After we've decided to create a DMS MVP with sensenet 7 on the new stack we had to rethink the whole store, the available actions, reducers and epics not only because it requires more and structured data but also because we provide a development platform to create custom solutions upon sensenet.

Btw [sn-redux](https://github.com/SenseNet/sn-redux) is a set of [Redux](http://redux.js.org/) actions, reducers and [redux-observable](https://redux-observable.js.org/) epics which means you get a package with 
- an optimized state tree with normalized data, 
- actions that can be dispatched related to the basic content, user and permission management features of sensenet,
- reducers to define state changes required by the above mentioned actions,
- epics to handle the sensenet OData actions and functions,
- and of course you can complete it with your actions, reducers and epics if you implement a custom feature.

Old version of sn-redux contained only things that can be used in a simple todo app. So there were only a few things available for creating a task, set it to *done*, delete it, etc. We knew that it should be restructured if we want to use it as a base of a content and feature heavier application.

First of all we've checked what sort of solutions were made with sensenet in the past and what could we provide at this level to help to accomplish them. We came to the conclusion that the most important things related to an application built upon sensenet are the context, the content items by permissions, basic document management features, content manipulation and user information. So these things became the key parts of the new Redux store in [sn-redux](https://github.com/SenseNet/sn-redux).

To let us now dig deeper in sensenet's Redux store (and make our life easier in development time) we integrated [redux-logger](https://github.com/evgenyrodionov/redux-logger) so that we can check how our state tree changes by the dispatched actions and last but not least we can show you how the tree is built-up, you can open every branch and look into it. If you've installed [sn-redux](https://github.com/SenseNet/sn-redux) and configure a store, you're able to see the log in the browser console when you dispatch an action.

![redux-logger in browser console](/img/posts/redux-logger.png, 'redux logger')

As you can see there are four reducers at the top level of sensenet: *children*, *currentcontent*, *selected* and *session*.

![redux-logger in browser console](/img/posts/sensenet-reducer.png, 'sensenet reducer')

**currentcontent** holds the state of the current content: you can access its metadata, its fields, the related sensenet actions and the state of the content which means you can check if it is dirty, in progress, saved or valid, and you can subscribe on all of the changes. If there was an error while loading content the error message is also stored here as the value of the *error* property.

![current content](/img/posts/currentcontent-store.png, 'current content in redux store')

In the **children** part you can access the current content's children in normalized form. For normalizing data we used [normalizr](https://github.com/paularmstrong/normalizr) which helps to structure (sometimes deeply) nested JSON objects which came as a response of an OData request. This works based on a schema definition with entities (in this case fetched content items) and a given param (in this case Id) that holds their unique identifier. So before data is added to the state tree it's normalized: there's an array with name *ids* that holds the items' ids and an object, *entities* that contains the Content items by their ids. Each content in the entities Object has an id that matches the key from the ids Array. This way manipulating (listing, selecting, deleting, etc) Content is much simpler. 
Some of the OData params are listed here too, so that it can be accessed later which Fields were selected, how items were ordered, if a filter was used, etc. It is also available here if the items are currently fetching or not, or if there was an error during the fetching process.

![children](/img/posts/children-store.png, 'children in store')

**selected** holds the id(s) of the selected Content item(s).

The **session** part contains information about the current *session*. There're a couple of user related stuff stored here like her fullname, path of her avatar image, chosen language and username, and there will be some browser related parameters stored like country and language settings. 
This part is the home of the *login state* too, so that you can subscribe to the state of the user, and control the authentication process. 
Last but not least the *repository* part contains the repository config, with the url of the requested repository and many other settings and defaults.

![session](/img/posts/session-store.png, 'session in store')

## Is this the final version? 

![The future is bright](/img/posts/thefutureisbright.gif, 'the future is bright')

Definitely not. While the DMS MVP and the admin surface of sensenet 7 is in progress, the Redux store of sensenet and [sn-redux](https://github.com/SenseNet/sn-redux) itself will change and improve continuously for sure. But we have laid the foundations of it and the future is bright, so any comments are welcome, help us make it better and better. [Redux](http://redux.js.org/) is awesome and I believe that it can make development with sensenet more fun then ever.

As you may already know [sensenet](https://sensenet.com)'s UI is being fully rebuilt on a new stack including [Redux](http://redux.js.org/). Since sensenet is also a development platform with the possibility of building your own app upon its Redux store and actions, let me guide you through the current version of the state tree showing you how we organized data so far.

2017-09-20-refactoring-sensenet-redux-store

Diving deeper into sensenet's Redux store

We had our project closing TGIF presentation last Friday where every team talked about their experiences - and you wouldn't believe what happened next!

Setting aside the subtle clickbait at the end of the intro, we learned *a ton* in these past six months. Just to recap, these were our goals when [we started out](http://community.sensenet.com/blog/2017/06/28/free-friday): 

- Create more vibrant **company culture** by incentivizing cross-team communication.
- Fire up developer **motivation** by letting them work on projects they love and by taking a breath of fresh air from the daily grind.
- **Empower** people. Let them *own* their projects and with them, our company culture, mission and values.

## Well, did we succeed?

Yes... well, sort of. We started this little experiment with three very different projects and teams. The results:

- 1 project that is about half complete

- 1 project, that has already been completed for 3 months

- and finally, 1 project, that is almost complete 

  ![Show me the data](/img/posts/data-on-my-desk-asap.gif, 'data on my desk')

## What went well?

### Tangible results

When we started Free Friday, we didn't have a Community Site and our Knowledgebase was falling apart. Now we have both! We also have a logo animation, which works in chrome.  

[TODO: insert sensenet logo gif here]

### Engaging presentations

Apart from the fact that almost always the same three guys talked about their projects, these events were pretty good. Even though, the size of the projects and the speed of development differed vastly, everyone could show real progress every month. I was particularly happy, because I could see people, who rarely ever give presentations talk in front of the whole company.

### Learning, learning, learning

After talking with the participants, one thing stood out: people from different teams use vastly different best practices. When we mixed these people, these best practices - more or less - were shared with each other.  Not much of a surprise here, but nevertheless... great!

## What did we learn?

### Governance is tricky

Without any recommendation for project management techniques or any formal supervision, teams tended to simply omit the 'management' part of the project. Which makes sense: if you have **small,** **mature** teams with **clear goals**, you don't *necessarily* need managers ([at least it works for Basecamp](https://m.signalvnoise.com/threes-company-df77db78d1af)). But Free Friday teams are - by definition - not mature teams and the goals are not always clear for *everyone*. So chaos can rear its ugly head pretty quickly.

### Sometimes half-measures are necessary after all

Sense/Net Inc. has two, very different company profiles. The **Business Solutions** division has vastly different metrics than **Product Development**. This is why the hardest part of getting this project through the management team was to have PO's quit obsessing about their teams' velocities. 

We needed everyone to be on board so Friday afternoons won't be interfered with, because an extremely important **last minute feature request** lands unexpectedly in the backlog. So we decided to have no half-measures. Either we're all all-in, or not.

And even though management was truly fully on board, developers sometimes decided to do their daily work instead, because they felt it was necessary (Hey, we have these responsible guys here. Good on us!). With wonky governance and sometimes-absent team members, there were Friday afternoons when people naturally defaulted back to business as usual.

![This is why we can't have nice things](/img/posts/whatevs.gif, 'whatevs')

### Communication is hard

If you've ever tried to form your fancy project idea into a digestible format for a very diverse set of people, when even *you* don't know, what you really want, then you know what I'm talking about. Developers could really experience what it's like to be in a stakeholder or leadership position. 

![Can we talk](/img/posts/canwetalk.gif, 'can we talk')

But it'll never work flawlessly for the first try. 

## What's next?

When I asked "Should we have another iteration of Free Friday?", the unanimous and immediate answer was 'absolutely'. In spite of the mentioned shortcomings, people enjoyed participating in the experiment. Communication got a little better and the company got almost two finished products at the end of this six months.

In the past two weeks people were already asking me, when can they start new projects. I've received pretty good project ideas too! So developers are enthusiastic, which is great.

![Reset the clock!](/img/posts/reset_the_clock.gif, 'reset the clock')

The next round is starting in **two weeks** and in the meantime, people can think up new project ideas. 

Just so we don't commit the same mistakes, we decided to change some of the original rules. These are:

- The next round is **3 months** long, instead of 6. Shorter iteration cycles should gradually produce better end-results.
- **Team sizes** can range from **1 to 3** people. The reason for at least 2-person teams was to incentivize collaboration between different teams. We realized though, that this way small, creative projects fall out of the basket. They'll get their chance now.
- People can move from one team to another within a, given the proper reasons. Right now we don't see why this should cause any troubles
- Presentations are every **2 week**. That's right, you have to talk *even more*.
- Free Friday is still on Friday afternoon. But if you have a Sprint Review and you talk with your FF and Business Solutions team, you can move your weekly 10% to a more appropriate time slot.

But otherwise everything stays the same. The type of the projects, the need for transparency and the frequent communication stays. My personal dream is that in time, most of the rules will wither away and this group dynamic we now call as 'Free Friday' will just melt into the company culture, enriching it with awesomeness.

See you in 3 months!

Six months have passed since we started our *very own* 'Sense/Net 10%' program, where any employee could assemble a team and work on a precious side-project in 10 percent of their time.

2017-09-13-freefriday-aftermath

We gave 10% freetime to our developers, this is what we've learned so far.

![new way of thinking](/img/posts/rethinking.jpg, 'rethinking')

The concept of a digital workplace is not only about a new ergonomic working environment, but it also encompasses a new way of thinking – both of which are, by themselves, beneficial not only to the enterprise, but also to its stakeholders.
Yet, however good the digital workplace might sound, it could be difficult for the people to accept the changes, especially when it requires a lot of effort from the single employees as well as from the different teams or groups as a whole. Employees may find the new concept to be too frustrating and stressful on them, especially when they are already overwhelmed with their professional work. As a leader of this transition it may be useful to let employees understand the benefits the digital workplace (or even a simpler document management system) would bring to them, in the hope that if they understand the need for this change, if they understand that digital workplace is not just another unnecessary bureaucratic burden, and if they feel that it is designed to make their work easier, they shall more readily and more willingly embrace the changes.

To this we need to understand the motivation of our employees, so that we could be able to act upon them, and thus to help the workforce adapt to the changes imposed by the digital workplace project. The whole organization shall be supportive and understanding of the employees’ needs and requirements as well, as this attitude creates an atmosphere of permanent satisfaction and improvement. Employees also have to understand that progress is needed in order to respond to the rapidly growing demands of the market. The shift to digital workplace is the interest of the employees themselves, provided it is important to them that they – we – have enough customers and orders, and thus do not have to be laid off.

It seems necessary to figure out what our colleagues feel to be beneficial for them. So, to gain insight into the motivation of the employees, it is worth asking them about their feelings.

A good way of this assessment can be via surveys or interviews and then constructing a portfolio from the responses.
Some of the questions we might ask are as follows:
- What motivates them to work in general?
- What motivates them to the adoption of the digital workplace?
- What are they hoping to gain through the digital workplace deployments?
- How do they prefer to work?
- Where do they like working?
- Do they prefer long or short tasks?
- How do they handle interruptions?

![ask questions](/img/posts/magnifying-glass.jpg, 'magnifying glass')

Sometimes different people may need different applications. The digital workplace may be better received if it accommodates to this need as well.

As an alternative to surveys we can also use empathy maps. Empathy maps will support the understanding of the employees’ reactions, their priorities at work; they will help us identify the behavioral motivation of our people. With the result we will be able to understand, segment and provide for employees, as well as to refine the features of the digital workplace.

A well-formatted needs statement is also helpful in finding and keeping the focus on the intended purpose of the digital workplace. The successful needs statement takes the following form: [User] needs a way to [user need] so that [direct benefit].

Thus, the most important and most beneficial way of involving our stakeholders in the deployment of a digital workplace is involving them in the design phase. As a result of this involvement we might hope that our colleagues will feel easy about the deployment, because their needs were considered throughout the process. If we manage to do some segmentation and pay attention to the needs, the whole deployment process will run more seamlessly.

Another way of motivating the stakeholders to use the digital workplace more willingly is to highlight its advantages to them. When they see the benefits the change offers them, they will adopt it with less embarrassment and frustration.

When we know how to accommodate the needs of the stakeholders and we actually do it, it is easier to motivate them to the adoption of the digital workplace. The idea is that the more motivated employees are, the more smoothly deployment of the digital workplace will run. As a result, every stakeholder shall be more satisfied and motivated, and thus the entire work process should run more coherently. The continuous workflow is definitely more profitable for the enterprise as a whole, as well as – directly and indirectly – to the employees themselves.

Digital workplace vendors bring tons of experience about solution deployment but company leaders must do their own homework to prepare real users for the changes. Employees’ engagement is a crucial part of successful project delivery. As always: do not underestimate the power of your users :)

By the second half of 2017, an enterprise that predestinates itself to be successful shall pay growing attention not only to making profit, but also to the changing needs of their stakeholders, including their employees.

2017-08-23-how-to-involve-employees-in-dws-deployments

How to involve your employees in digital workplace deployments?

Yet, many people still think that the constant documenting slows down creative work, thus decreases productivity. This is however a mistaken thought and as such it does not show forward thinking.

From the 80’s flexibility and innovation are the building blocks of companies. It is especially true for small and medium-sized businesses as in these areas they can be competitive with multinational corporations with million dollar budgets. The basis of innovation is the development of 'traditional knowledge', the striving to acquire and distribute 'new knowledge'. Reaching this is impossible without appropriate company content handling.

Organizing and managing ever-growing structured and unstructured data and transfer of corporate knowledge is impossible, if the important information, the software used by the company and the colleagues themselves are not connected.

![document information](/img/posts/knowledgebase.jpg, 'knowlegdebase')

## In what form does it happen?
Knowledge, that is useful from the viewpoint of innovative processes, can come from several sources. Information necessary for operation is usually provided by the leadership. The company can however get valuable knowledge from its consumers, employees or from information derived from the behavior of the competition.

Imagine a complex process with several participants. The main goal is processing large amount of information and documents, storing and distributing them securely long-term. A system that makes it easy to prepare and retrieve statistics compiled from the stored information that are essential for making decisions. What you imagined is enterprise content management (ECM) and it is the skeleton of companies' digital workplaces.

## How can it be made available to employees?
Believe it or not, the key to the secret is not the software, but its integration considering business processes and objectives. The real question is: how the appropriate information is going to reach predetermined decision points? How difficult it is to retrieve a certain document in case of an inspection? How can new colleagues access several years of knowledge?
The format of the material you work with does not matter. Whether it is an electronic document, paper-based document, letter, email, fax, some kind of multimedia content, text or chat message, it can be integrated into one system. ECM solutions handle different datatypes easily as they are equipped with the properties of several applications and file managers.

Your only task is to assign employees to different authorities, lists or libraries and they can easily access knowledge relevant to them.

![educate new employees](/img/posts/learn.jpg, 'learn')

## How is this supported by a well-organized IT system
In most companies - probably in yours as well - archiving and organizing documents is one of the biggest problems. In our example **sensenet** handles problems related to storing, security settings, title management, version control, software integration, sharing and formatting at the same time. The data stored this way can also be retrieved easily thanks to the metadata indexing capabilities.

This is how a unified content management system brings out the most of the digital working environment:

-	Version control: preserving different versions of a document and retrieving an earlier version in case of an error;
-	Office integration: documents in sensenet document libraries can be edited directly in Microsoft Office as well;
-	"Shared drive replacement": it is like opening a drive, the libraries in the content repository can be accessed from any kind of file manager (e.g. Windows Explorer or Total Commander) – you don't need to open them in the browser;
-	Document library title management: you can assign work processes to lists and libraries and you can assign users with different permissions to them;
-	Check-in / check-out function: no more data loss while you are working on a draft.

There are different kinds of content management systems you can choose from. Do it wisely, because it will dramatically influence your digital experience in the short run 🙂

If you have more questions about sensenet, do not hesitate to [contact us](https://www.sensenet.com/contact), we will be happy to answer your questions!

Why is it important to document information? The answer is fairly simple: documented company knowledge is easily transmitted, multiplied or updated, and it can be stored securely.

2017-08-16-internal-knowledge-sharing

Internal knowledge sharing - is it the base of the company brain?

We could stay with the old asp.net solution or create a custom no-framework one but we ended-up using [React](https://facebook.github.io/react/) and [Aurelia](http://aurelia.io/). In the following post I try to sum up the whys and hows behind choosing React.

### Main goals

Working with the past versions of [sensenet](https://sensenet.com) was not always easy. Especially when you wanted to change the ui. This was one of the key improvement points that we've detected and defined it as one of the main tasks for the development of future versions. We wanted to pimp up the ui anyway, so it was also important for us to find a solution for building a new admin surface and creating other building blocks of the public ui easier and more effectively.

We wanted to reduce the learning curve in the first place. In the old version of sensenet the building blocks of the ui were customizable to the smallest details which was great, but it was also the main reason why the customization was a huge work. There were html pagetemplates for the skeleton of a page, there were ascx views and xslt renderers displaying the components and js and there were css source files not to mention celltemplates, fieldcontrol templates, etc. As you can see it is at least four different technologies and all these things were stored in separate places in the repository. It was not easy to see through what, where and how should be customized. So it was clear that the front-end development should be unified.

On the other hand it was an important need from the start that if we rewrite the whole ui and everything that is related, the new solution should be componentized, testable (and tested), easy to deploy, accessible and should meet the industry standards, because it is a must if you want to be not only a simple cms but a development platform too.
The no-framework solution was rejected very early because of the huge work. On the other hand there are tons of frameworks on the market which were potential options to fulfill our needs. So we just had to try them out...

### It's not all about the hype

![Hype train](/img/posts/hypetrain.gif "Hype train")

Our selection may seem a bit ad-hoc but we tried to check out the most popular frameworks. We're working on a development platform so it was clear from the start that the chosen framework should be futureproof and a one with a great community. We've agreed to try out [react](https://facebook.github.io/react/), [aurelia](http://aurelia.io/), [vuejs](https://vuejs.org/), [angular](https://angularjs.org/) and [angular2+](https://angular.io/) with building a todo app with them upon sensenet 7. Not all of them was evaluated by me, so I will reflect only on those that I've tried and just for a few words because it's more important why we've chosen React and why not Angular for example. 

[Angular2+](https://angular.io/) seemed a perfect match at the beginning because it's written in TypeScript and we love to write our stuff in TypeScript too, but at the same time it was a bit more difficult to learn it than the others and however it's not likely to happen again, Angular was completely rewritten once and we had to choose a long-term solution.

[Vuejs](https://vuejs.org/) is easy to learn and easy to use if you want to build a small project. But it was not really recommended for large scale apps and it has unfortunately a smaller ecosystem than the others.

(We've also built and improving continuously a control lib for [aurelia](http://aurelia.io/), maybe [@gallayl](https://github.com/orgs/SenseNet/people/gallayl) will tell us in another post why he chose it and what experiences he had with it. 😉)

### So why React exactly

1. Simplicity
    - It will take more time to learn the best practices but its learning curve is quite steep,
    - It's Javascript-centric which empower its simplicity,
    - Easy to add new features,
    - Tons of 3rd party libraries to use.
2. Virtual DOM   
    - Fast rendering,
    - React is not a real framework but 'view layer only' fits our needs in most of the cases.
2. JSX
    - Javascript-centric design
    - Easy to learn, easy to read
3. [Redux](http://redux.js.org/)
4. Tooling
    - [Great CLI](https://facebook.github.io/react/blog/2016/07/22/create-apps-with-no-configuration.html),
    - [Testability](https://github.com/facebookincubator/create-react-app/blob/master/packages/react-scripts/template/README.md#running-tests),
    - Scalability,
    - Great tools to help documenting and creating styleguides.
5. Ecosystem
    - Great support and community.
6. Non-web stuff 
    - It's not part of the scope yet but [React Native](https://facebook.github.io/react-native/) or [next.js](https://github.com/zeit/next.js/) look promising when we talk about native rendering.

### All that glitters is not gold

Working with React and [TypeScript](https://www.typescriptlang.org/) is not always as easy and fun as it sounds. Since we decided going along with TypeScript in our other projects it was clear that this one will be written in TS too. To be short unfortunately not all the above mentioned great stuff can be used (easily) if you want to *stick yourself to the rules*. 

[Webpack](https://webpack.github.io/) could be also the bad guy sometimes but it is maybe because we are not so experienced in it yet.

### The results

![React todo app](/img/posts/react-todoapp.png "React todo app")

At the end we've made a control package, [sn-controls-react](https://github.com/SenseNet/sn-controls-react) with the basic view and field controls. It's open-source and since it's not finished feel free to add or modify it yourself. We are continuously developing it so we hope that it can be used as the base of sensenet's new admin surface and public ui in the near future.

It is built upon [sn-client-js](https://github.com/SenseNet/sn-client-js) that provides the API and lets us manipulate the sensenet [Content Repository](http://community.sensenet.com/docs/content-repository/). It also uses [sn-redux](https://github.com/SenseNet/sn-redux) which is a set of redux actions and reducers for sensenet Content management features. [sn-controls-react](ttps://github.com/SenseNet/sn-controls-react) has an ultra flexible mapping based on sensenet [CTD's](http://community.sensenet.com/blog/2017/07/19/how-to-make-your-life-infinitely-better-sensenet-ctd) and FieldSettings which provides us Content management surface (create, edit, browse) generation. And last but not least it is built with [react-materialize](https://react-materialize.github.io/#/) so it meets the standards and is customizable in common ways.

We are open and want to build a great community around sensenet so your opinion is super important to us. Please try, review and comment our work and help us make the world a better place! 😻

- [React controls for sensenet](https://github.com/SenseNet/sn-controls-react)
- [Example todo app built with React+Redux upon sensenet](https://github.com/SenseNet/sn-react-redux-todo-app)
- [A set of redux actions, reducers and redux-ovbservable epics for sensenet](https://github.com/SenseNet/sn-redux)
- [A JavaScript client for sensenet that makes it easy to use the REST API of the Content Repository.](https://github.com/SenseNet/sn-client-js)
- [Aurelia controls for sensenet](https://github.com/SenseNet/sn-controls-aurelia)
- [Example todo app built with Aurelia + Redux upon sensenet](https://github.com/zoltanbedi/sn7-aurelia-redux-todo-app)
- [Todo App with Angular, Redux and sensenet](https://github.com/blaskodaniel/sn-angular-redux-todo-app)
- [Example todo app built with Angular2+Redux upon sensenet](https://github.com/SenseNet/sn-angular2-redux-todo-app)
- [Example todo app built with Vue+Redux upon sensenet](https://github.com/SenseNet/sn-vue-redux-todo-app)

One of the key points of developing sensenet 7+ was how can we provide nicer ui for our end-users and a more accessible dev platform for the front-end developers at the same time.