10 Useful Bootstrap Editors To Build Responsive Websites

Bootstrap is hugely used in responsive web development and that's why we need Bootstrap editors to drag all the Boostrap components into a canvas. These editors and builders make prototyping, testing and building responsive websites easier. Each editor is different but all of them feature some drag and drop facility through a huge library of components. Here is a list of 10 best Bootstrap editors for building responsive websites.

1. Bootply: 

Bootply is a playground for Bootstrap which is not only an editor and builder but is a repository to extensive codes too. It enables dragging and dropping Bootstrap components and then edits the code. It's integrated with popular Bootstrap plug-ins, micro-libraries and frameworks.

2. Jetstrap: 

It's a web-based JavaScript library which allows building rapid prototypes and applications with Bootstrap. It's very simple to use and has a powerful interface with drag-and-drop functionality. It allows dropping elements, customising them and see a live preview while the entire code is completely formatted. Multiple device emulators are tested within the workspace and it can export code easily to run the website faster.

3. Bootstrap Magic: 

It's one of the most useful editors which helps generate own Bootstrap theme by providing live previews. It reduces developers' work burden and increases efficiency. It uses Angular JS and the recent Bootstrap 3 too to give live preview of all actions.

4. Brix.io: 

Brix is an online Bootstrap builder which is quite powerful and sleek looking too. It enables creation of responsive interfaces and websites faster than ever. Brix provides smooth and well-formatted HTML, CSS and JS with any hosting service and with this editor you can also create projects as editing and commenting become easy with this builder.

5. Divshot: 

It allows fast front end development and it works with most popular frameworks like Bootstrap, Foundation and Ratchet. It has several component libraries which are completely customised for each framework and the visual HTML editor supports custom code, JavaScript, CoffeeScript, LESS and more. The theme switcher is also very useful.

6. BootSwatchr: 

If you're at the initial stage of building a website or you want to change a website's theme then the best editor for you is BootSwatchr because it's highly customisable. You can do anything as you wish with your website.

7. Pinegrow: 

This is a desktop app used in Mac, Windows and Linux systems. With Pinegrow developers can mockup and design web pages with multi-page editing, CSS and LESS styling. It also features smart components for Bootstrap, Foundation and other frameworks. This tool saves all your efforts and time too.

8. Kickstrap: 

It's a free editor and a front-end framework which comes bundled with Bootstrap library. You can choose which CSS and JS components you want to use in website development and keep the framework's layers updated. It doesn't require any installation as it's out of the box and you can put it directly on your server.

9. Bootstrap Live Editor: 

It helps you customise HTML based website through snippets and contents. It also allows perform advanced customisations like button configuration and localisation.

10. LayouIt: 

It's very simple and effective interface builder to make front end coding easier. You can use its base templates and drag and drop Bootstrap elements onto the canvas. Then download the HTML and add your own styling to integrate it with any programming language.


reference :
http://www.efytimes.com/e1/fullnews.asp?edid=151553&magid=11

20 Tools And Resources For Building And Testing Regular Expressions

Regular expression, or regex or regexp or rational expression, is a series of strings in a particular sequence, which is used to create a search pattern and applied in “find and replace” like tasks. It's mainly used in computer science theories. Regular expression was first introduced in 1950s by Stephen Kleene, an American mathematician. It's commonly used in UNIX operating system and Linux commands for find and replace kind of tasks. Here we'll provide a list of 20 best tools and resources which will help you in writing regular expressions in a more streamlined way.

1. Regexr: 

This tool is used for online purposes in building and testing regular expressions like RegEx or RegExp. It updates real-time results while typing the expression only.

2. Expresso: 

It's a desktop tool suitable for beginners and it also offers a feature-rich environment for programmers as well as web designers.

3. Regex101: 

It's again an online tool which is used for RegEx which has debugging capabilities for detecting errors and explaining real-time results. It's used for programming languages like PHP, JavaScript and Python.

4. Rad Software Regular Expression Designer: 

It's based on a regex application, which is based on Interactive Windows, and it's simple to use. This tool requires .NET framework to be functional.

5. RETester: 

This tool is used for regular expressions in the target string and this tool supports engines like .NET, Client side engine and Silverlight Tester.

6. HTML2Regexp – Regular Expression Generator for HTML Element: 

It's a program written in Ruby which generates regular expressions for extracting HTML elements.

7. Rubular: 

Ruby Expression Tester is also used for Ruby-based regular expression to test real-time expressions while typing the same.

8. reWork: 

This is an online tool which is used for functions like replace, split, scan and so on. With this tool too, results can be updated while typing only.

9. Regexpal: 

It's written in JavaScript and its features include case insensitive, global and multi line anchors and Dot matches all. Both the regular expression and the string should be used to test in different fields for the results.

10. Txt2re: 

It's a very tiny tool which puts together regex patterns. It supports Perl, PHP, Python, Java, Javascript, C, C++, Ruby, VB, VBScript, .NET and more.

11. Rex V: 

This regular expression is based on Ajax and it's used for three different systems - PHP PCRE, PHP Posix and Javascript.

12. Regexhero: 

This tool is >NET based and it highlights real-time expressions. It also offers syntax highlighting and generates code in both C# and VB.NET.

13. Debuggex: 

It's a visual tester used online and it also includes a live text editor. This web application is written in JavaScript and supports all modern browsers.

14. Flex 3 Regular Expression Explorer: 

It's a regular expression test site which has a large community and it offers samples too.

15. Regexplanet: 

It is used for testing regular expression in Java and it can also be used for other engines like JavaScript, Java, .NET, Pearl, Python and Ruby.

16. Freeformatter: 

It allows testing regular expressions against any entry as per your choice and it also highlights all the found matches.

17. Myregextester: 

It allows online visitors to build and test regular expressions. It also optimises entered expressions and highlights matching patterns in the result area.

18. Python Regular Expression Testing Tool: 

It's a Python based tool for testing regular expressions and it supports specific functions like dotall and unicode.

19. Regexr From Gskinner: 

It's an online tool used for both editing and testing regular expressions like RegEx. Having a user-friendly interface, this tool also shows real-time matches.

20. Regex Tester From Gethifi: 

This tool comes from Gethifi and it uses JavaScript for testing regular expressions through jQuery. It's a powerful tool for web developers and designers. 


Reference:
efytimes

7 Programming Languages Set To Revolutionise Software Development

Are you looking to establish yourself as a programmer? Then there are some very essential languages which you must learn. If you are very serious about the programming domain and have extensive knowledge then you must be aware of the fact that the list of essential programming languages remain the same over years. Programmers are always advised to improve skills in C, Java, Objective C, PHP and the similar types. But the exciting part is there are few new languages which are getting introduced slowly with huge potential and entering the mainstream programming too. Some of the languages are evolved from existing languages. The newer languages are helpful towards making applications simpler for programmers. Let's talk about seven such languages on the board:
1. D: 

This is one of the hottest new programming languages which is used by Facebook. It's a refreshed version of C++ and it takes its inspiration from Python, Java, Ruby, Eiffel and C#. It's easy to write a code with D and it also doesn't require a pre-processor. It can also tackle Unicode excellently. D is growing to expand its reach in coming years a lot with high efficiency and productivity.

2. Dart: 

Dart is created by Google which is expected to become the new language for web programming.
Dart uses C like syntax and keywords and its objects are defined through classes and interfaces. Dart allows programmers to declare variables with static types, though its optional. Dart is not very usable today but it has a strong future. It's a strong competitor for JavaScript.

3. Ceylon: 

The creator of Ceylon programming language, Gavin King, knew it best how to create a language which is better than Java. That's why King created Ceylon in collaboration with Red Hat. This language is said to have potential to kill Java one day. It works on the Java runtime environment only which means java has a huge role to play in Ceylon. But Ceylon offers regular syntax and developers are allowed to overcome the limitations of Java.

4. Go: 

It's a programming language used for application development to system programming. It's more similar to C and C++ than Java and C#. It has some modern features too like garbage collection, runtime reflection and more. Go language is an easy option to program with and its basic syntax is like C. The Go team aims to create a dynamic scripting language. The language is still under development and it differs from other languages a lot.

5. F#: 

Computer scientists are quite familiar with the concept of functional programming but programming languages like C++ and Java lack from integration of functional-style code into libraries. Here comes F# or F-sharp which is a Microsoft language and both functional as well as practical. It's based .NET common language runtime.

6. Opa: 

Web development is not a very simple thing to do. Web apps require several coding in multiple languages. HTML and JavaScript are required on the client, Java and PHP are required for server, SQL is required for database and more. Opa is not an alternative to the existing programming languages. It's a combination of client and server frameworks.

7. Scala: 

Scala is more than often compared to Java. It's not very new as it's there for ten years but it's not considered one of the most essential programming languages. But Scala is said to be very productive by developers as it's concise and more functional programming style is used in it. It also offers a potent mix of object oriented and functional programming. 

Loading Related Entities

Entity Framework supports three ways to load related data - eager loading, lazy loading and explicit loading. The techniques shown in this topic apply equally to models created with Code First and the EF Designer.

The following topics are covered on this page:

• Eagerly Loading
  • Eagerly loading multiple levels
• Lazy Loading
  • Turn lazy loading off for serialization
  • Turning off lazy loading for specific navigation properties
  • Turn off lazy loading for all entities
• Explicitly Loading
  • Applying filters when explicitly loading related entities
• Using Query to count related entities without loading them

Eagerly Loading

Eager loading is the process whereby a query for one type of entity also loads related entities as part of the query. Eager loading is achieved by use of the Include method. For example, the queries below will load blogs and all the posts related to each blog.

using (var context = new BloggingContext()) 
{ 
    // Load all blogs and related posts 
    var blogs1 = context.Blogs 
                          .Include(b => b.Posts) 
                          .ToList(); 
 
    // Load one blogs and its related posts 
    var blog1 = context.Blogs 
                        .Where(b => b.Name == "ADO.NET Blog") 
                        .Include(b => b.Posts) 
                        .FirstOrDefault(); 
 
    // Load all blogs and related posts  
    // using a string to specify the relationship 
    var blogs2 = context.Blogs 
                          .Include("Posts") 
                          .ToList(); 
 
    // Load one blog and its related posts  
    // using a string to specify the relationship 
    var blog2 = context.Blogs 
                        .Where(b => b.Name == "ADO.NET Blog") 
                        .Include("Posts") 
                        .FirstOrDefault(); 
}

Note that Include is an extension method in the System.Data.Entity namespace so make sure you are using that namespace.

Eagerly loading multiple levels

It is also possible to eagerly load multiple levels of related entities. The queries below show examples of how to do this for both collection and reference navigation properties.

using (var context = new BloggingContext()) 
{ 
    // Load all blogs, all related posts, and all related comments 
    var blogs1 = context.Blogs 
                       .Include(b => b.Posts.Select(p => p.Comments)) 
                       .ToList(); 
 
    // Load all users their related profiles, and related avatar 
    var users1 = context.Users 
                        .Include(u => u.Profile.Avatar) 
                        .ToList(); 
 
    // Load all blogs, all related posts, and all related comments  
    // using a string to specify the relationships 
    var blogs2 = context.Blogs 
                       .Include("Posts.Comments") 
                       .ToList(); 
 
    // Load all users their related profiles, and related avatar  
    // using a string to specify the relationships 
    var users2 = context.Users 
                        .Include("Profile.Avatar") 
                        .ToList(); 
}

Note that it is not currently possible to filter which related entities are loaded. Include will always being in all related entities.

Lazy Loading

Lazy loading is the process whereby an entity or collection of entities is automatically loaded from the database the first time that a property referring to the entity/entities is accessed. When using POCO entity types, lazy loading is achieved by creating instances of derived proxy types and then overriding virtual properties to add the loading hook. For example, when using the Blog entity class defined below, the related Posts will be loaded the first time the Posts navigation property is accessed:

public class Blog 
{  
    public int BlogId { get; set; }  
    public string Name { get; set; }  
    public string Url { get; set; }  
    public string Tags { get; set; }  
 
    public virtual ICollection<Post> Posts { get; set; }  
}

Turn lazy loading off for serialization

Lazy loading and serialization don’t mix well, and if you aren’t careful you can end up querying for your entire database just because lazy loading is enabled. Most serializers work by accessing each property on an instance of a type. Property access triggers lazy loading, so more entities get serialized. On those entities properties are accessed, and even more entities are loaded. It’s a good practice to turn lazy loading off before you serialize an entity. The following sections show how to do this.

Turning off lazy loading for specific navigation properties

Lazy loading of the Posts collection can be turned off by making the Posts property non-virtual:

public class Blog 
{  
    public int BlogId { get; set; }  
    public string Name { get; set; }  
    public string Url { get; set; }  
    public string Tags { get; set; }  
 
    public ICollection<Post> Posts { get; set; }  
}

Loading of the Posts collection can still be achieved using eager loading (see Eagerly loading related entities above) or the Load method (see Explicitly loading related entities below).

Turn off lazy loading for all entities

Lazy loading can be turned off for all entities in the context by setting a flag on the Configuration property. For example:

public class BloggingContext : DbContext 
{ 
    public BloggingContext() 
    { 
        this.Configuration.LazyLoadingEnabled = false; 
    } 
}

Loading of related entities can still be achieved using eager loading (see Eagerly loading related entities above) or the Load method (see Explicitly loading related entities below).

Explicitly Loading

Even with lazy loading disabled it is still possible to lazily load related entities, but it must be done with an explicit call. To do so you use the Load method on the related entity’s entry. For example:

using (var context = new BloggingContext()) 
{ 
    var post = context.Posts.Find(2); 
 
    // Load the blog related to a given post 
    context.Entry(post).Reference(p => p.Blog).Load(); 
 
    // Load the blog related to a given post using a string  
    context.Entry(post).Reference("Blog").Load(); 
 
    var blog = context.Blogs.Find(1); 
 
    // Load the posts related to a given blog 
    context.Entry(blog).Collection(p => p.Posts).Load(); 
 
    // Load the posts related to a given blog  
    // using a string to specify the relationship 
    context.Entry(blog).Collection("Posts").Load(); 
}

Note that the Reference method should be used when an entity has a navigation property to another single entity. On the other hand, the Collection method should be used when an entity has a navigation property to a collection of other entities.

Applying filters when explicitly loading related entities

The Query method provides access to the underlying query that the Entity Framework will use when loading related entities. You can then use LINQ to apply filters to the query before executing it with a call to a LINQ extension method such as ToList, Load, etc. The Query method can be used with both reference and collection navigation properties but is most useful for collections where it can be used to load only part of the collection. For example:

using (var context = new BloggingContext()) 
{ 
    var blog = context.Blogs.Find(1); 
 
    // Load the posts with the 'entity-framework' tag related to a given blog 
    context.Entry(blog) 
        .Collection(b => b.Posts) 
        .Query() 
        .Where(p => p.Tags.Contains("entity-framework") 
        .Load(); 
 
    // Load the posts with the 'entity-framework' tag related to a given blog  
    // using a string to specify the relationship  
    context.Entry(blog) 
        .Collection("Posts") 
        .Query() 
        .Where(p => p.Tags.Contains("entity-framework") 
        .Load(); 
}

When using the Query method it is usually best to turn off lazy loading for the navigation property. This is because otherwise the entire collection may get loaded automatically by the lazy loading mechanism either before or after the filtered query has been executed.

Note that while the relationship can be specified as a string instead of a lambda expression, the returned IQueryable is not generic when a string is used and so the Cast method is usually needed before anything useful can be done with it.

Using Query to count related entities without loading them

Sometimes it is useful to know how many entities are related to another entity in the database without actually incurring the cost of loading all those entities. The Query method with the LINQ Count method can be used to do this. For example:

using (var context = new BloggingContext()) 
{ 
    var blog = context.Blogs.Find(1); 
 
    // Count how many posts the blog has  
    var postCount = context.Entry(blog) 
                          .Collection(b => b.Posts) 
                          .Query() 
                          .Count(); 
}