In this post I’ll reference what I consider to be the most interesting and hot topics on the React community… and try to make it short.

If you haven’t seen the conference, you can take a look at this YT playlist for all sessions.

The state of React 2022

So first of all, what is the state of React currently? With React 18, what was once called concurrent mode is now concurrent features. This changes the approach into an incremental adoption, so that you could use concurrent features in specific places of your React app.

In this talk, Lee also announces Next.js new routing system which resembles Remix a lot. They want to take advantage of nested routes which is great! This allows us to provide a better user experience on pages that have one component that blocks rendering.

Last but not least, there are new developments when it comes to server-side rendering, and new client-side rendering APIs.

Edge computing

If you are unaware of this type of compute, Edge computing allows a better user experience, because it reduces the time you get a response with the content you want to visualize. The time is reduced because to process your request you don’t need to “talk” to a distant server on the oasis.

CDN providers like Cloudflare, are building new runtimes to allow you to run code closer to your customers – on the edge. Cloudflare workers for example, don’t use Node.js or Deno under the hood, it’s their own JS runtime. Of course, an effort is being done to standardize these runtimes.

In this talk, Kent talks about how Remix improves the developer experience for edge computing. First they use the Web Fetch API, and depending on where you want to deploy your function. Remix then translates the request/response objects to the respective platform’s API. They also support streaming in the edge, in order to send some content to the user quickly, and then send the rest.

With that said, this is all in JS/TS or WASM land. At least I haven’t seen a lot of support for other languages and runtimes (e.g. C#) on services that provide edge computing.

Streaming server components

With React 18 it’s now possible to stream changes to the browser, with new APIs like Suspense that allows for asynchronous processing.

Why is this cool? Because we don’t want to block rendering with data fetching. When our component needs to fetch data before rendering what the user wants to see, we need to render a loading spinner… which ain’t cool.

How about we initiate fetches before we render. This way the requests are in parallel and don’t block rendering. Using streaming server rendering fixes this, which is why it’s so awesome! Ryan Florence goes more in detail how this is done in this talk: When to fetch: Remixing React Router.

Bear in mind, this is just one way of rendering. Last year at React Conf 2021 there was an intro session about this topic as well: Streaming Server Rendering with Suspense. Another great session that talks about the different rendering patterns: Advanced Rendering Patterns: Lydia Hallie. It’s an amazing session to help you visualize the impacts on performance, and what are the trade-offs of each pattern.

The post Reactathon 2022 – A Short Summary appeared first on Blog IT.

There are two types of 404 routes that we want to handle.

• Static 404 – the URL the user navigates to doesn’t match any route
• Dynamic 404 – the URL matches a route, but the data associated with that route does not exist. For example, you navigate to a detail page with an ID, but no item exists with that ID.

For this post, I assume that there is a component named NotFoundComponent that is the not found page to show the user. Replace this with whatever component

Static 404 routes

To set up a static 404 page, you need to add two routes to your RoutingModule configuration.

const routes: Routes = [
    // Other routes
    { path: '404', component: NotFoundComponent },
    { path: '**', component: NotFoundComponent }
]

We used a catchall route '**' that matches whatever route didn’t match above, and shows our not found page.

Make sure to keep the catchall route at the end of your routes, otherwise the routes below it will not be accessible.

Another option here would’ve been to redirect the user to the '404' route, but that way you lose the context of the URL. If the user navigates back, he would go to the non-existing route and be redirected to the '404' path again. If this is the behavior you want, switch the last route with { path: '**', redirectTo: '404' }.

Dynamic 404 routes

Now that we have the static 404 route configured, we can use the router to navigate to it whenever we want to show the not found page to the user.

this.router.navigate(['/404'], { skipLocationChange: true });

By using the option skipLocationChange: true, we have the same behavior as mentioned above. Even though the router navigates to the route, the browser URL stays the same, allowing the user to easily go back.

Personalizing the 404 message

You may want to personalize the message shown on the 404 page. One way to do this is using the navigation state.

When navigating to the 404 page, you can include a state in the navigation options.

this.router.navigate(['/404'], { 
    skipLocationChange: true,
    state: {
        // Whatever data you need on the 404 page
    	source: 'article',
        id: 123456
    }
});

On your NotFoundComponent, you can access this object in the constructor using the router’s getCurrentNavigation method.

export class NotFoundComponent {
  constructor(private router: Router) {
    console.log(this.router.getCurrentNavigation().extras.state.source);
  }
}

You must access the state in the constructor, as it is only available while the router is navigating.

Conclusion

In this post, we saw how to implement a 404 route in Angular. We looked at how we can redirect to it dynamically and even how to personalize the 404 page with route dependent data!

Have questions, corrections, or an alternative way of handling this? Leave a comment or reach out to me on Twitter @pedronavelopes and let me know! Thanks for reading!

The post Handling not found routes in Angular appeared first on Blog IT.

I would like you to keep in mind that this will not make your website fully accessible, it’s just an easy way to vastly improve accessibility.

1 – Follow WCAG and WebAIM checklist

The WCAG (Web Content Accessibility Guidelines) is a set of guidelines on how the web can be made more accessible. It takes 4 principles into consideration:

1. Perceivable – Just because something is perceivable with one sense (usually sight), not all users can perceive it
2. Operable – Can users use UI components and navigate the content. For example, hover interactions can’t be operated by someone without a mouse
3. Understandable – Can all users understand the content
4. Robust – Is it robust enough for the content to be consumed by a wide variety of user agents, and does it work with accessibility tools.

The WebAIM Checklist was created from these guidelines and simplified the implementation of these principles. This checklist should be seen as a companion to start implementing accessible interfaces, not as the final resource on what make a website accessible.

2 – Provide alternatives to non-text content

Non-sighted users may have a hard time taking in non-text content, as such, it’s important to provide alternatives to these.

• Provide alt text for images The alt text should be an alternative to the image content
  • If an image is not relevant for the context, you can hide it from screen readers by providing an empty alt text.
• Use aria-label for other elements
  • The aria-label lets you label elements for screen readers

// 👎 No descriptive alt text
<img src="puppy.jpg">

// 👍 Descriptive alt text
<img src="puppy.jpg" alt="Labrador puppy running in the grass">

// 👍 Empty alt text excludes the image that isn't relevant
<button>
	<img src="home-icon.jpg" alt="">
	Home
</button>

3 – Use native and semantic elements

When implementing an HTML page, try to use native and semantic elements.

If you need a button, you should use a <button> element, not a div with an onclick event or an anchor link.

This is the case because different elements mean different things, and have different behaviors. By using the native HTML elements, we know it will have the expected behavior. And by using a semantic element, we ensure that the user understands what the element will do, as in, a button will trigger an action, and a link will trigger a navigation to somewhere else.

// 👎 Non-semantic element
<div class="button" click="onclick">
	Click me!
</div>

// 👍 Semantic element
<button click="onclick">
	Click me!
</button>

4 – Use ARIA attributes in elements

When there is no native element which matches your need, you may have to implement it yourself.

To make sure the element you are implementing is accessible, you should use ARIA (Accessible Rich Internet Applications) attributes.

These will allow you to add semantics to elements which have no meaning, modify existing semantics, add extra labels and descriptions, express relationships between elements, etc.

The ARIA practices document specifies the patterns that each element should have. When implementing an element, you give it a role and commit to following all the patterns and interactions defined in the ARIA practices.

5 – Understand focus and tab order

Tab order refers to the order in which the items on a page will be focused using the keyboard.

Some elements are implicitly focusable (such as inputs, buttons and links), and are added to the tab order automatically.

The tab order is determined by the DOM order, but this can be different from the visual order which can be changed by CSS. Therefore, you should make sure that the reading and navigation order are logical and intuitive.

To change the tab order, you can use the tab index attribute:

• -1
  • Removes the element from the natural tab order, but it is focusable through code.
  • Useful when we have hidden elements (such as modals) which should not be focusable when hidden
• 0
  • Adds the element to the natural tab order.
  • Allows elements to be focused and receive keyboard input.
• 0
  • Jumps element to the front of the tab order
  • If there are multiple elements, order goes from lowest to highest
  • This is discouraged because it can make it confusing for screen readers, as they navigate the page linearly

Make sure you have a focus ring. A focus ring lets users know which element is focused. This is essential for keyboard users.

6 – Bypass Blocks

If your page has a lot of navigation links, a keyboard user will have to tab through all these links before being able to reach the main content. To make your website more convenient to use, you can provide users with a skip link.

The skip link will be the first focusable element on the page and links the user to the main content, skipping the focus to it directly.

<body>
  <a href="#maincontent">Skip to main content</a>
  <!-- Navigation links --->
  <main id="maincontent">
    <h1>Heading</h1>
    <p>This is the first paragraph</p>
  </main>
</body>

To make sure the skip link doesn’t affect your page, you can hide it until it is focused, meaning only keyboard users will see it.

Alternatively to skip links, if you provide a proper heading structure, screen readers will also be able to skip around the page and navigate to each section much more easily. This will, however, not provide a skip mechanism for users who just use the keyboard to navigate.

7 – Use ARIA attributes in CSS selectors

You can use ARIA attributes in your CSS selectors. This makes sure that ARIA is being used correctly, and removes the need for additional selectors.

// 👎 Aditional selector
.toggle.pressed

// 👍 ARIA attributes
.toggle[aria-pressed="true"]

8 – Responsive design

Even if you don’t need to implement mobile designs, a responsive design ensures that the user can zoom in the page and the content adjusts properly. Your page should be zoomable up to 200% without losing content or functionality.

• Use relative font-size, allowing the browser to rescale the text
• Use appropriate touch targets (>48px) so users have enough space to touch a single button
• Space touch targets about 32px from each other

9 – Color and Contrast

There are tools which allow you to easily check for contrast. Some browsers even let you check this directly in the dev tools.

You also have to keep in mind that some users will not be able to distinguish some colors. As such, information should not be conveyed by color alone. Make sure you add other elements (such as captions or icons) to indicate the state of the elements.

10 – How to apply these tips

Good accessibility ensures good UX. As such, accessibility should be focused from the beginning of development.

When this doesn’t happen, we inevitably have to fix accessibility issues later. You can identify some issues using the following techniques:

• Use the accessibility inspector included in the browser
• Navigate through your website using only a keyboard
• Simulate impaired vision through browser extensions (e.g. NoCoffee)

After identifying some issues, how should we tackle them? As with bugs, we should focus on high impact, low effort issues.

• How frequently is this piece of UI used?
• How badly does this affect our users?
• How expensive is it to fix?

Conclusion

Accessibility is starting to make it to the front of developer concerns. With more popularity come more resources to help us develop better interfaces and experiences for all users.

Hopefully, this article provided you with an initial idea on how to approach web accessibility.

The post 10 easy ways to improve web accessibility appeared first on Blog IT.

Both use https and I want the main site, which uses the primary domain, to only be accessible through it’s www version. For the second site, since it’s a sub-domain, I only want it to only be available in https.

Let’s say the domain is mydomain.com and the subdomain is mysub.mydomain.com. The only URLs I want to be available are:

• https://www.mydomain.com
• https://mysub.mydomain.com

Typically I would make the non-www to www redirection through the DNS provider, but for this website it was not possible.

The following is the configuration I used in my Web.config:

<rewrite>
    <rules>
        <rule name="Redirect from non www mydomain.com" stopProcessing="true">
            <match url=".*" />
            <conditions>
                <add input="{HTTP_HOST}" pattern="^mydomain.com$" />
            </conditions>
            <action type="Redirect" url="https://www.mydomain.com/{R:0}" redirectType="Permanent" />
        </rule>
        <rule name="Redirect from non https mydomain.com" stopProcessing="true">
            <match url=".*" />
            <conditions>
                <add input="{HTTPS}" pattern="^OFF$" />
                <add input="{HTTP_HOST}" pattern="^www.mydomain.com$" />
            </conditions>
            <action type="Redirect" url="https://www.mydomain.com/{R:0}" redirectType="Permanent" />
        </rule>
        <rule name="Redirect from non https mysub.mydomain.com" stopProcessing="true">
            <match url=".*" />
            <conditions>
                <add input="{HTTPS}" pattern="^OFF$" />
                <add input="{HTTP_HOST}" pattern="^mysub.mydomain.com$" />
            </conditions>
            <action type="Redirect" url="https://mysub.mydomain.com/{R:0}" redirectType="Permanent" />
        </rule>
    </rules>
</rewrite>

Hope this helps!

The post Redirecting 2 domains from http to https and non-www to www appeared first on Blog IT.

• This enables you to have an Angular application alongside your Umbraco website, on a specified route.
• The Angular App can be protected by the Authentication of your website, if you have it. And you can make use of surface controllers for authenticated requests.
• The routing of your app will work as intended, for example, if your Angular app is at /app and you make a request to /app/products, the request will be routed to the angular app products’ page.

What this is not

• A complete front end for a Umbraco website with dynamic routes.
• This doesn’t have dynamic routes, you have to specify them on your code.

Let’s get started!

First, start by creating a controller to handle the Angular App request.

using System.Web.Mvc;

public class AngularAppController : BaseController
{
    public ActionResult AngularAppView()
    {
        return View();
    }
}

Then, you have to decide the route where your Angular app will render. On this example it will be /angularapp.

On your ApplicationStarted method, put this code:

RouteTable.Routes.MapRoute(
  "AngularApp",
  "angularapp/{*.}",
  new { controller = "AngularApp", action = "AngularAppView" });

The {*.} syntax is what makes your angular app routes load and not return the 404 page.

If you don’t have an ApplicationStarted method, find out how you to create it here: https://our.umbraco.org/documentation/reference/events/application-startup

Under your Views folder, create a folder with the same name as the controller you set in MapRoute. In this case it will be “AngularApp”.
Inside it, create a view with the same name as the action set you set in MapRoute.

Inside the view put the contents of the index.html of your angular app.
Then you will need to move your angular app files somewhere like you /Assets folder, and edit their paths on the view.

Almost done!

Now you need to edit the routes of your Angular app.
Simply add the route you chose as a prefix to the routes.

From something like this:

const routes: Routes = [
  { path: '', redirectTo: '/dashboard', pathMatch: 'full' },
  { path: '/dashboard', component: DashboardComponent },
  { path: '/detail/:id', component: HeroDetailComponent },
  { path: '/heroes', component: HeroesComponent }
];

To this:

const routes: Routes = [
  { path: 'angularapp', redirectTo: 'angularapp/dashboard', pathMatch: 'full' },
  { path: 'angularapp/dashboard', component: DashboardComponent },
  { path: 'angularapp/detail/:id', component: HeroDetailComponent },
  { path: 'angularapp/heroes', component: HeroesComponent }
];

Thanks for reading!
Mário

The post Adding an Angular app to your Umbraco Website appeared first on Blog IT.

We ended up serving both the assets and content images through the same Microsoft Azure CDN. This post describes the way we implemented it.

First the easiest part. We have our site in a Azure Website, in order to serve the site’s assets through an Azure CDN we only needed to point the CDN to the website’s URL. So, if the website’s assets are located in something like http://sitedomain/assets/*, instead of referencing the assets through a relative url such as /assets/*, we just need to use the CDN url to serve them: http://cdnurl/assets/*. Through web.config transforms we are also able to use local assets during development and change to CDN only on the production environment.

Regarding the website image content, the solution has three phases.

1. The content is managed over SharePoint 2013, and the images are no exception. We created a feature receiver that uploads to Azure Blob Storage every time an image is uploaded, or modified,  on any Picture Library, and then save its known CDN URL in the library item.

string cdnUrl = Configuration.Settings.ImageUploader.CdnUrl;
string containerStr = Configuration.Settings.ImageUploader.Container;

// Retrieve storage account from connection string.
CloudStorageAccount storageAccount = CloudStorageAccount.Parse(
    CloudConfigurationManager.GetSetting(IMAGES_STORAGE_CONNECTION_STRING));

// Create the blob client.
CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();

// Retrieve reference to a container.
CloudBlobContainer container = blobClient.GetContainerReference(containerStr);

// Creates the container if it doesn't exist
container.CreateIfNotExists();

// Set the blobs access level to public
container.SetPermissions(new BlobContainerPermissions
{
    PublicAccess = BlobContainerPublicAccessType.Blob
});

string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(file.Name);
string extension = Path.GetExtension(file.Name);

fileNameWithoutExtension += "-" + DateTime.Now.Ticks;

// Build file name to upload
string fileName = string.Format("{0}/{1}{2}", file.Item.ParentList.Title.ToLower(), fileNameWithoutExtension.Replace(" ", "-"), extension).ToLower();

// Retrieve reference to a blob named "file.name".
CloudBlockBlob blockBlob = container.GetBlockBlobReference(fileName);

// Create or overwrite the "file.name" blob with contents from a local file.
using (var fileStream = file.OpenBinaryStream())
{
    blockBlob.UploadFromStream(fileStream);

    // Update SP item CDN URL column
    string finalUrl = HttpUtility.UrlPathEncode(string.Format("{0}/{1}/{2}?{3}", cdnUrl, containerStr, fileName, IMAGE_RESIZER_FIRST_PARAMETER));

    properties.ListItem[Configuration.Settings.SP_COLUMN_CDN_URL] = finalUrl.ToLower();
    properties.ListItem.SystemUpdate(false);
}

2. Having the images in a Azure Blob Storage, we decided to use the Image Resizer ASP.NET Library and its AzureReader2 plugin to resize and serve images directly through our Azure Website. The implementation is as easy as installing a nuget package: Image Resizer. After configuring the Blob Storage endpoint, and setting the prefix (we use ~/azure), we are able to access the images through an URL such as: http://sitedomain/azure/image/path/in/blobstorage. With this working we can resize and modify the images in any way available to us with the Image Resizer library and described in detail here: http://imageresizing.net/docs/v4.

3. Since our CDN is pointing directly to our Azure Website, we can use the CDN URL instead of the azure website one. For instance, the fake image I talked about the previous bullet can be accessed with the following URL: http://cdnurl/azure/image/path/in/blobstorage. This way, the first time someone opens an image through the CDN URL it is handled by the Image Resizer library. The  second time, CDN has already cached it and distributed it around the world and it is served much faster!

The post Azure CDN, BlobStorage and ImageResizer appeared first on Blog IT.

This is a super short guide to a successful experience with Sharepoint 2013 FBA Pack.  For a fully detailed process please refer to Chris Coulson’s life saving article.

Our goal?

Provide FBA authentication in our SahrePoint application

What we need?

The SharePoint2013FBAPack zip file with the Activate.ps1, Deploy.ps1, UnDeploy.ps1and Visigo.Sharepoint.FormsBasedAuthentication.wsp files.

Our three simple steps?

1. Create users database
2. Install the Sharepoint 2013 FBA Pack
3. Configure web application

1. Create users database

1. Go to c:\windows\Microsoft.NET\Framework64\v4.0.30319\
2. Run “aspnet_regsql.exe”
   1. Choose “Configure SQL Server for application services” -> click Next
3. Now that you have created your users database, you must make sure that the the identity running you SharePoint application pool can access it.
   1. Where can you find this identity?  In IIS ->“Application Pools”. Check the value in the Identity column of you SharePoint application pool. Take a note, you’ll need it later.
      1. Open SQL server as an Administrator -> Go to Security/Logins -> Select the user that matches the identity identified earlier -> Right click -> Select Properties -> Check the “Map” box for the database created previously and check the “db_owner” role. -Now the db is ready!

2 . Install the Sharepoint 2013 FBA Pack

1. If you haven’t download -the pack zip file do it now 🙂 and extract its content
2. Open a Powershell and navigate to the pack extraction path.
3. Run “Set-ExecutionPolicy Unrestricted” and “.\deploy [Site Collection URL]

3. Configure Web Application

Now that we have a membership database,  that our SharePoint pool identity can access it and that the FBA pack is installed, we need to configure the membership provider in the config files.

From the approaches described in Chris Coulson’s life saving article. I would recommend to avoid the approach that involves machine.config editing, because unless  you’re doing something very special you don’t really want to disseminate your apps specifics beyond its scope.

With this in mind, also make sure you always backup  your .config files before editing any “tiniest” change to avoid spending hours trying to resolve a character typo our encoding mistakes.

We are going to add the same changes to three different config files. You can find each of these by navigate through IIS -> right click the application -> Explore -> Double click the “web.config” file :

• SharePoint Central Administration
• SecurityTokenServiceApplication
• Your SharePoint application web application

1. In the <ConnectionString> section add the following line, make sure that [SERVER NAME] matches the fully-qualified name of your db server:

   <add connectionString="Server=[SERVER NAME];Database=aspnetdb;Integrated Security=true" name="[CONNECTION STRING NAME]" />

2. In the <membership><providers> section add the following and make sure that [CONNECTION STRING NAME]  matches the value of the previous step:

   <add name="[MEMBERSHIP PROVIDER NAME]"
    type="System.Web.Security.SqlMembershipProvider, System.Web, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"
    connectionStringName="[CONNECTION STRING NAME]"
    enablePasswordRetrieval="false"
    enablePasswordReset="true"
    requiresQuestionAndAnswer="false"
    applicationName="/"
    requiresUniqueEmail="true"
    passwordFormat="Hashed"
    maxInvalidPasswordAttempts="5"
    minRequiredPasswordLength="7"
    minRequiredNonalphanumericCharacters="1"
    passwordAttemptWindow="10"
    passwordStrengthRegularExpression="" />

3. In the <roleManager><providers> section add and make sure that [MEMBERSHIP PROVIDER NAME] and [CONNECTION STRING PROVIDER NAME] match the values of the previous steps.:

   <add name="[MEMBERSHIP PROVIDER NAME]" connectionStringName="[CONNECTION STRING NAME]" applicationName="/"
    type="System.Web.Security.SqlRoleProvider, System.Web, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />

Now  you’ll be able to add the Membership Provider to your web application when enabling the Forms Based Authentication.

Ok, so… this might not be super-short, but it is short enough. Just be extra careful when editing the config files and you won’t have to worry about anything else.

The post Super short guide to a successful SharePoint 2013 FBA Pack Installation appeared first on Blog IT.

My session was about Working with AngularJS, a fantastic Single Page Application framework in JavaScript. It’s an introductory session, meant to give attendees a basic understanding of the framework and its components. I had a packed room, with around 200 people, and the feedback was great so I felt it might be worth sharing the slides and demos I wrote for the session:

• Slides (on OneDrive)
• Slides (on SlideShare)
• Demos (on OneDrive)

You’re probably wondering why would I, a SharePoint guy, be talking about AngularJS. SharePoint guys are not exactly known for embracing the latest and greatest web technologies, mostly because when a new SharePoint version is released, it’s already one .Net version behind, not to mention all the new JavaScript frameworks. With SharePoint 2013, all that is changed. The new SharePoint App Model allows us to build our apps in any technology we want, and that means we can use all the big boys toys now such as ASP.NET MVC and, of course, AngularJS.

Also presenting a session on WebCamp about KnockoutJS was my good friend and colleague João “Jota” Martins, which is a great JavaScript data-binding library. Although they share some concepts, Knockout and Angular are very different technologies, on very different abstraction levels, so it’s good to know when to use one or the other. Checkout his slides and code samples here.

The post Microsoft WebCamp 2014: Working with AngularJS appeared first on Blog IT.

Earlier, my colleague and friend André “SharePoint God” Vala did a session on AngularJS, so we got to share information on two libraries with very different levels of abstraction for web development. Had about 70-80 people in the room, in what was session with more code samples I’ve done for some time now.

You can download the slides here or check them on Slideshare, and the code samples are here.

The post Microsoft WebCamp 20.05.2014–Databinding with KnockoutJS appeared first on Blog IT.

I think in this version Microsoft did a very good job, it's amazing what they've done in 3 years, not just in the WCM part but in the entire product. 

About WCM there is a lot of improvements, the new ribbon makes life easier for content producers, for designers it's possible to controls what styles can be used on the RichTextEditor.

Has i said before SharePoint is compliant with WCAG acessibility guidelines http://www.w3.org/TR/WCAG/

Now it's easier to upload pictures to SharePoint, tags that are set in local images are also promoted to SharePoint. It's possible to use wiki pages in public sites with all the look and feel of the public site, and the free structure of the new wiki pages.

The Search Engine Fields  now appears on page in edit mode.

There is a new Asset library and a new Media Player WebPart (Silverlight), now it's possible to streaming videos from the blob cache, the CQW (Content Query WebPart) has some new features like the PageFieldValue where it's possible to filter the content of the CQW using a the value of a field in the page.

A very bit improvement it the possibility to have different host headers for each site collection in one Web Application.

It's now possible to manage a site in any browser (IE, FireFox, Safari)

Now you can export publishing workflows and then reuse them in any site that you want, without the need for creating and filling for each site a new workflow.

The Incremental Content Deployment that gave so many headaches to a lot of SharePoint Administration now is more reliable with a better logging and diagnostics, it's now possible to use Point in time snapshots on SQL Enterprise also with more logging and diagnostics.

The post Web Content Management in SharePoint 2010 appeared first on Blog IT.