<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>Weblog on Dmitry Sheiko&#39;s Web Development Blog</title>
    <link>https://dsheiko.com/</link>
    <description>Recent content in Weblog on Dmitry Sheiko&#39;s Web Development Blog</description>
    <generator>Hugo -- gohugo.io</generator>
    <language>en-us</language>
    <lastBuildDate>Wed, 22 Jan 2020 16:38:32 &#43;0100</lastBuildDate>
    
	&lt;atom:link href=&#34;https://dsheiko.com/index.xml&#34; rel=&#34;self&#34; type=&#34;application/rss&#43;xml&#34; /&gt;
    
    
    <item>
      <title>Must-Know Web Development Concepts in 2026</title>
      <link>https://dsheiko.com/weblog/must-know-web-development-concepts-2026/</link>
      <pubDate>Thu, 05 Mar 2026 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/must-know-web-development-concepts-2026/</guid>
      <description>Software can be perfectly functional, secure, and even performant, yet still become a long-term problem. The real test of a system is not whether it works today, but whether it can survive tomorrow’s requirements. When code becomes difficult to modify, every small change risks breaking something unrelated. Features take longer to implement, bugs appear in unexpected places, and eventually even simple improvements feel dangerous.
Maintainability is what prevents this scenario. When a codebase is designed with maintainability in mind, it can evolve without constant fear of collapse.</description>
    </item>
    
    <item>
      <title>How to Add Web Push Notifications to a Next.js App</title>
      <link>https://dsheiko.com/weblog/how-to-add-web-push-notifications-to-nextjs-app/</link>
      <pubDate>Wed, 11 Feb 2026 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/how-to-add-web-push-notifications-to-nextjs-app/</guid>
      <description>Web Push notifications have quietly become one of the most effective engagement channels on the web. They don’t require an email address. They don’t depend on social algorithms. And they work even when your website isn’t open.
If you run a blog, SaaS, e-commerce store, or internal platform, Web Push can dramatically improve retention and real-time communication.
Let’s walk through what Web Push actually is, how it works under the hood, and how you can implement it in a Next.</description>
    </item>
    
    <item>
      <title>How to Create a Global Custom 404 Page for Route Groups in Next.js</title>
      <link>https://dsheiko.com/weblog/nextjs-global-404-route-groups/</link>
      <pubDate>Fri, 23 Jan 2026 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/nextjs-global-404-route-groups/</guid>
      <description>Implementing a custom 404 page in Next.js versions &amp;lt;=16 can be surprisingly tricky when using route groups. By default, Next.js expects a not-found.jsx file to be placed next to the layout of a route. But what happens when you have multiple route groups with different layouts? Let’s dive in.
Suppose we have two route groups, each with its own layout and not-found.jsx:
app ├── (admin) │ ├── admin │ ├── layout.</description>
    </item>
    
    <item>
      <title>Mastering Tables and Modals in Next.js 16: Patterns That Preserve State</title>
      <link>https://dsheiko.com/weblog/mastering-tables-and-modals-nextjs-16/</link>
      <pubDate>Fri, 14 Nov 2025 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/mastering-tables-and-modals-nextjs-16/</guid>
      <description>When developing administrative UIs, one of the most common patterns is a table to navigate database records and modals to view or edit individual entries.
In Next.js, this can be achieved in several ways — not only with Parallel Routes, which are the officially recommended approach in the documentation.
In this article, I’ll share three different implementation strategies I explored and discuss their pros and cons based on real-world use cases.</description>
    </item>
    
    <item>
      <title>Optimizing End-to-End Testing with Playwright: A Practical Guide</title>
      <link>https://dsheiko.com/weblog/optimizing-end-to-end-testing-with-playwright/</link>
      <pubDate>Tue, 25 Mar 2025 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/optimizing-end-to-end-testing-with-playwright/</guid>
      <description>End-to-end (E2E) testing is a crucial step in ensuring that web applications function as expected across different scenarios, devices, and browsers. However, maintaining efficient and reliable tests can be challenging. This is where Playwright shines — offering a powerful and developer-friendly framework for robust E2E automation.
In this guide, we will explore how to optimize Playwright for E2E testing, covering best practices for improving test readability with fixtures, handling authentication flows, working with data tables, and verifying responsive design. Additionally, we will dive into performance budgets to maintain a smooth user experience. Whether you&amp;rsquo;re transitioning from Selenium or Cypress, or you are new to Playwright, this guide will help you write cleaner, more maintainable tests that ensure your web applications perform flawlessly.</description>
    </item>
    
    <item>
      <title>Next.js 15 Tutorial: Build a Full-Stack App with Ant Design &amp; React Query</title>
      <link>https://dsheiko.com/weblog/nextjs-15-tutorial/</link>
      <pubDate>Wed, 26 Feb 2025 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/nextjs-15-tutorial/</guid>
      <description>At the beginning of 2025, Next.js is likely the best choice for React developers building server-side applications. Personally, I&amp;rsquo;m used to developing apps without a framework. I typically use Express.js to write a REST API server with both SSR and client-side rendering. While this approach offers maximum flexibility, it comes at the cost of excessive boilerplate code. It also requires manually handling caching, pre-fetching, routing, HTTP cache management, and more. Take image optimization, for example.</description>
    </item>
    
    <item>
      <title>Refactoring Legacy React Code: Moving from OOP to Functional Components</title>
      <link>https://dsheiko.com/weblog/refactoring-legacy-react-code/</link>
      <pubDate>Mon, 17 Feb 2025 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/refactoring-legacy-react-code/</guid>
      <description>When React Hooks arrived in 2019, switching to functional components seemed impractical. But as the ecosystem evolved, new techniques emerged. This article explores key strategies for migrating class-based components to modern React patterns—leveraging composition, useImperativeHandle, and function-based customization. Ready to embrace the future of React?</description>
    </item>
    
    <item>
      <title>From Zero to Blog: Getting Started with Hugo</title>
      <link>https://dsheiko.com/weblog/building-a-blog-with-hugo/</link>
      <pubDate>Wed, 04 Mar 2020 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/building-a-blog-with-hugo/</guid>
      <description>This blog hadn’t a redesign for a decade. It was driven by self-made CMS, which naturally has become, say the least of it, outdated. So some time ago I ripened for a remastering. Instantly I started by looking for a CMS or a headless CMS. Then I realized, the blog is actually static – I don’t have here any forms or services, it’s all about representation of content. Why not to go with a site generator?</description>
    </item>
    
    <item>
      <title>Puppetry 3: Test Automation without Coding</title>
      <link>https://dsheiko.com/weblog/puppetry-3-test-automation-without-coding/</link>
      <pubDate>Wed, 27 Nov 2019 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/puppetry-3-test-automation-without-coding/</guid>
      <description>Nowadays nobody would argue the importance of automated testing. Yet end-to-end tests are often hard to write and even harder to maintain. There are many solutions to help with it. Puppetry is a test constructor, which allows you building test suites without any coding. QA-engineer can record user scenario in a built-in browser, extend the generated test case with browser commands and assertions, manage the suite structure (like drag’n’drop) and run tests.</description>
    </item>
    
    <item>
      <title>Enhancing UX with LQIP: How to Build an Awesome Image Preview</title>
      <link>https://dsheiko.com/weblog/how-to-create-a-kick-ass-image-preview-with-lqip/</link>
      <pubDate>Thu, 11 Jul 2019 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/how-to-create-a-kick-ass-image-preview-with-lqip/</guid>
      <description>Images in HTML, what could be easier? However when you have many of them on a page, they do not appear immediately. That depends on caching strategy and bandwidth, but still if you don’t take a special care it may look quite ugly. Basically we need to fill in the slots with something appropriate while images are loading. In other words we need placeholders. Probably the most prominent technique here is LQIP (low quality image placeholder).</description>
    </item>
    
    <item>
      <title>Testing Email Activation in Sign-Up Flows: A Step-by-Step Guide</title>
      <link>https://dsheiko.com/weblog/testing-sign-up-flow-with-activation-by-email/</link>
      <pubDate>Mon, 08 Jul 2019 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/testing-sign-up-flow-with-activation-by-email/</guid>
      <description>Functional testing isn’t something new. We all do it, less or more, with different tools and approaches. However when it comes to flows, where transactional emails (signup confirmations, password resets, purchase notifications and others) involved that may still bring questions. For example, we instruct the testing tool to navigate to the registration page, fill out the form and press the submit button. The web-application sends email with activation link. So we need the testing tool to read the email message, parse it and navigate the link.</description>
    </item>
    
    <item>
      <title>Puppetry 2.0 released</title>
      <link>https://dsheiko.com/weblog/puppetry-2-0-released/</link>
      <pubDate>Mon, 01 Jul 2019 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/puppetry-2-0-released/</guid>
      <description>Eventually Puppetry 2.0 was released. The development took for a while, yet it contains a lot of changes. In fact the branch 1.x was basically a GUI for Puppeteer/Jest, but the tool grew up into a fully-fledged testing environment.
Now Puppetry has a built-in templating engine, which supports environment-dependent variables and expressions, what brings a great potential. Just consider: you have test/stage service, which never resets. The only way to test, let’s say, signup flow is to create a new (no-yet-existing) user account.</description>
    </item>
    
    <item>
      <title>Validating Function Arguments in JavaScript: The Smart Way</title>
      <link>https://dsheiko.com/weblog/validating-arguments-in-javascript-like-a-boss/</link>
      <pubDate>Thu, 23 May 2019 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/validating-arguments-in-javascript-like-a-boss/</guid>
      <description>In software engineering we try to discover and eliminate bugs as soon as possible. One of most important heuristics here is validation of input/output on functions and methods. If you are going with TypeScript or Flow, you are fine. But if not? Then we have to manually validate at least input (arguments). But what would be the best way doing it?
First comes to mind aproba library. It&amp;rsquo;s &amp;ldquo;ridiculously&amp;rdquo; light-weight and equally popular:</description>
    </item>
    
    <item>
      <title>Puppeteer for E2E Testing: How to Automate Your Web Tests</title>
      <link>https://dsheiko.com/weblog/end-to-end-testing-with-puppeteer/</link>
      <pubDate>Mon, 11 Jun 2018 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/end-to-end-testing-with-puppeteer/</guid>
      <description>A sound application architecture doesn&amp;rsquo;t resist to changes, but welcomes them. Yet it still doesn&amp;rsquo;t guarantee that the code is unbroken after we implement new features, making fixes or refactoring. Here we run automated tests to ensure that the app integrity didn&amp;rsquo;t suffer. So we write unit-tests to check if separate objects, methods, functions work property independently. With integration tests we ensure they play as designed together. Eventually we create system tests to find out if the entire system meets our business requirements.</description>
    </item>
    
    <item>
      <title>Effortless Form Handling in React with the HTML5 Validation API</title>
      <link>https://dsheiko.com/weblog/handling-forms-with-react-and-html5-form-validation-api/</link>
      <pubDate>Tue, 05 Jun 2018 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/handling-forms-with-react-and-html5-form-validation-api/</guid>
      <description>When we talk about user input within a web app we often think first of HTML forms. Web forms have been available with the very first editions of HTML. Apparently the feature was introduced already in 1991 and standardized in 1995 as RFC 1866. We use them everywhere, with almost every library and framework. But what about React? Facebook gives a limited input on how to deal with forms . Mainly it&amp;rsquo;s about subscribing form and controls for interaction events and passing state with &amp;ldquo;value&amp;rdquo; property.</description>
    </item>
    
    <item>
      <title>Optimizing Your Dev Workflow with Webpack 3</title>
      <link>https://dsheiko.com/weblog/javascript-and-underscore-js-type-methods-in-php/</link>
      <pubDate>Thu, 12 Apr 2018 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/javascript-and-underscore-js-type-methods-in-php/</guid>
      <description>I’ve been working with PHP since 2000 and with JavaScript even longer. Over last decade JavaScript evolved drastically. It had a promising design from the very beginning and gained its current incredible shape with the shift to ES2015 (Harmony). PHP though didn’t change that much. Apparently it’s doomed always to suffer from its own legacy. It arrived in middle 90s as a simple CGI app to maintain Rasmus Lerdorf’s home page and have been more like spontaneously developing ever since.</description>
    </item>
    
    <item>
      <title>Setting Up Dev Environment with Webpack 3</title>
      <link>https://dsheiko.com/weblog/setting-up-dev-environment-with-webpack-3/</link>
      <pubDate>Mon, 11 Dec 2017 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/setting-up-dev-environment-with-webpack-3/</guid>
      <description>I observe as some people still write ancient ES5 syntax of JavaScript and it’s disheartening. I wonder what keeps them from moving forward. Some must be driven by psychological inertia, but some likely just find it to complex to make their new syntax running in a wide range of browsers. In fact, nowadays we may not fear about it anymore. One can set up a dev environment where tools decide what transformations requires the code and what polyfills to load depending on selected target (list of user agents to support).</description>
    </item>
    
    <item>
      <title>Leveraging HTML5.2 for More Functional and Interactive Web Apps</title>
      <link>https://dsheiko.com/weblog/building-real-life-applications-with-functional-elements-of-html-5-2/</link>
      <pubDate>Tue, 15 Aug 2017 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/building-real-life-applications-with-functional-elements-of-html-5-2/</guid>
      <description>What do you do when you need a widget-like functionality? At the present there is a whole generation of developers who with as a rule are googling for ready-made jQuery plugin. Can&amp;rsquo;t we do better than that? With advance of web-components we are expected to compose UIs from these building blocks. They are many. One can find one for almost any task. They are highly customizable. One can reuse the functionality, but with own original representation.</description>
    </item>
    
    <item>
      <title>JavaScript Modules in 2017: Where We Stand and What’s Next</title>
      <link>https://dsheiko.com/weblog/state-of-javascript-modules-2017/</link>
      <pubDate>Thu, 10 Aug 2017 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/state-of-javascript-modules-2017/</guid>
      <description>Before modules Historically JavaScript had neither a module system, nor facilities to load sources from within the code. In order to understand what have now, let&amp;rsquo;s take a retrospective look. I remember in the past a number of libraries where the code-base was split into a separate files which were concatinating during the build process. As simply as that it didn&amp;rsquo;t help with module isolation, but improved maintainability by organizing the code in files of meaningful names.</description>
    </item>
    
    <item>
      <title>My book `Cross-platform Desktop Application Development Electron, Node, NW.js, and React` is out</title>
      <link>https://dsheiko.com/weblog/cross-platform-desktop-application-development-electron-node-nw-js-and-react-is-out/</link>
      <pubDate>Mon, 31 Jul 2017 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/cross-platform-desktop-application-development-electron-node-nw-js-and-react-is-out/</guid>
      <description>I always fancied to write a book that would combine most of my programming experience gathered over two decades. Packtpub gave a chance that I embraced gratefully. And here we are, half a year of efforts paid off and my book is live - https://www.packtpub.com/web-development/cross-platform-desktop-application-development-electron-node-nwjs-and-react
I split the book in four tutorials, starting with basics and advancing progressively though more and more complex aspects. So the first part guides on creating a file-explorer application built with pure JavaScript and NW.</description>
    </item>
    
    <item>
      <title>Bringing Angular 2&#43; Development Experience into Backbone</title>
      <link>https://dsheiko.com/weblog/second-wind-for-backbone/</link>
      <pubDate>Mon, 10 Oct 2016 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/second-wind-for-backbone/</guid>
      <description>I&amp;rsquo;ve been working with Backbone for years and it suited me pretty well. I do love its conciseness. It gives the desired abstraction and yet leaves you at the full control of your app. When you need to know what exactly is happening in your app behind your code, it&amp;rsquo;s matter of minutes to go though the Backbone annotated sources and figure out the flow. That&amp;rsquo;s something you hardly can afford with other frameworks such as Angular, React, Vue or Amber.</description>
    </item>
    
    <item>
      <title>Stop Bugs Before They Happen: Function Guards in JavaScript</title>
      <link>https://dsheiko.com/weblog/guarding-functions-in-javascript/</link>
      <pubDate>Fri, 07 Oct 2016 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/guarding-functions-in-javascript/</guid>
      <description>As developers we spend a lot of our time on debugging and particularly on spotting the source of a problem. DevTools guides us though the call stack, but the tracing process can be still pretty time consuming, especially on a cascade of asynchronous calls. The remedy here is early problem reporting.
Let&amp;rsquo;s say we have a function to search trough a multidimensional structure for the elements containing a given string. We make a call that looks like legit:</description>
    </item>
    
    <item>
      <title>Nightmare of End-to-End Testing</title>
      <link>https://dsheiko.com/weblog/nightmare-of-end-to-end-testing/</link>
      <pubDate>Wed, 28 Sep 2016 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/nightmare-of-end-to-end-testing/</guid>
      <description>Modern application get complex, we cannot go without automated testing. The canonical agile testing quadrants are split to technology-facing and business-facing tests. As for technology-facing testing I believe nowadays everybody has dealt with unit-tests. Thus we make sure that the smallest parts of the system act as intended in isolation. Also we use component tests to verify the behavior of large parts of the system and integration tests to check if communication between object isn&amp;rsquo;t broken.</description>
    </item>
    
    <item>
      <title>Writing Backbone Applications in TypeScript</title>
      <link>https://dsheiko.com/weblog/writing-backbone-applications-in-typescript/</link>
      <pubDate>Fri, 16 Sep 2016 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/writing-backbone-applications-in-typescript/</guid>
      <description>Nowadays JavaScript evolves fast. We have ECMAScript 6th and 7th editions released over just 2 years. the current support of ES6 specification in major browsers is close to 100%. So the language changed, and changed for better. It has become more expressive, much more concise and readable. It is tempting to jump into, but what about older browsers? Transpilers can translate ES.Next into the old-good JavaScript of ECMAScript 5th edition.</description>
    </item>
    
    <item>
      <title>Enhancing User Experience: Missing chapter of my book `Unlocked JavaScript`</title>
      <link>https://dsheiko.com/weblog/enhancing-user-experience/</link>
      <pubDate>Tue, 08 Dec 2015 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/enhancing-user-experience/</guid>
      <description>My book “Unlocked JavaScript” (https://www.packtpub.com/web-development/javascript-unlocked) has been released on December 7, 2015.
This book is for developers already familiar with JavaScript who want to level up to get the most out of the language. The book is practice–oriented and would be most helpful for those who is used to learn by doing as the topics are thoroughly covered with real-life examples and tutorials. This is an extract of a chapter not included in the book.</description>
    </item>
    
    <item>
      <title>Responsive Web Design: Best Practices for Improving Performance</title>
      <link>https://dsheiko.com/weblog/responsive-web-design-best-practices-for-improving-performance/</link>
      <pubDate>Fri, 30 Jan 2015 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/responsive-web-design-best-practices-for-improving-performance/</guid>
      <description>User are impatient. Majority would leave a resource if it failed delivering the core user experience in 1-3 seconds. Today when mobile overtakes fixed Internet access you need to think of how the app loads on a low bandwidth, what images must requested on what devices, how stylesheets and JavaScript are cached e.t.c. Fortunately there a number of amazing tools such as PageSpeed Insights, WEBPAGETEST, Pingdom Website Speed Test. So you can find out what&amp;rsquo;s wrong with your app in terms of web-performance.</description>
    </item>
    
    <item>
      <title>Automated CSS Regression Testing in Action: A Developer’s Guide</title>
      <link>https://dsheiko.com/weblog/automated-css-regressive-testing-in-practice/</link>
      <pubDate>Thu, 15 Jan 2015 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/automated-css-regressive-testing-in-practice/</guid>
      <description>We write unit-tests tests for server-side source code and for JavaScript. Even when putting aside benefits of TDD approach it gives us a priceless thing – early problem reporting during refactoring. So you make change, you run tests and you will know at once if anything broke. What about CSS? You encapsulate a declaration set into a separate rule, look through the site pages where dependent classes used and satisfied proceed with refactoring.</description>
    </item>
    
    <item>
      <title>Modularizing and Packaging JavaScript for Scalable, High Performance Web Apps</title>
      <link>https://dsheiko.com/weblog/modularizing-and-packaging-javascript-for-scalable-high-performance-web-apps/</link>
      <pubDate>Fri, 07 Nov 2014 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/modularizing-and-packaging-javascript-for-scalable-high-performance-web-apps/</guid>
      <description>Modules in JavaScript With the advance of MV* frameworks you can observe as JavaScript evolves ahead of official specs towards large scale development. It requires even higher level of maintainability and one of the first focuses here is encapsulation and information hiding. We need the code-base to be organized into independent, interchangeable components so that each of them contained code implementing only one aspect of desired functionality. Here comes to help the Module pattern.</description>
    </item>
    
    <item>
      <title>10 Things You Need to Know About CSS</title>
      <link>https://dsheiko.com/weblog/10-things-to-need-to-know-about-css/</link>
      <pubDate>Tue, 14 Oct 2014 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/10-things-to-need-to-know-about-css/</guid>
      <description>CSS may look as a simple language. In fact it can be simple only to use, but definitely not simple to maintain.
Observing that the maximum number of people who can productively simultaneously work on CSS is one &amp;ndash; @threedaymonk
The skills required to write good CSS code are by and large the same skills required to write good code in general. &amp;ndash; Lea Verou Everybody who used to work on a large-scale projects knows how hard it can be to keep constantly growing CSS sources readable and consistent, styles reusable and loosely coupled.</description>
    </item>
    
    <item>
      <title>Creating a web-component: VanillaJS vs X-Tag vs Polymer</title>
      <link>https://dsheiko.com/weblog/creating-a-web-component-with-vanillajs-x-tag-and-polymer/</link>
      <pubDate>Wed, 10 Sep 2014 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/creating-a-web-component-with-vanillajs-x-tag-and-polymer/</guid>
      <description>It seems like these days the most trending concept in the HTML5 world is web components. But what the fuss is all about? In order to make such a simple thing as a container expanding on click in past we needed to write CSS and JavaScript. Today thanks to checkbox-hack and :focus or :target pseudo-selector we go on with CSS-only. In fact by using summary/details elements we do not need any tricks with CSS to make it working, considering that browser already supports this feature.</description>
    </item>
    
    <item>
      <title>Pure CSS Magic: Creating Stylish Modal Windows Without JavaScript</title>
      <link>https://dsheiko.com/weblog/fancy-modal-windows-without-javascript/</link>
      <pubDate>Wed, 20 Aug 2014 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/fancy-modal-windows-without-javascript/</guid>
      <description>What we are going to do is a modal window that opens in the center of the screen by pressing a link while everything that underlies the window becomes blurred. It can be done by [Dialog element](http://www.whatwg.org/specs/web-apps/current-work/multipage/forms.html#the-dialog-element &amp;ldquo;Dialog` element&amp;rdquo;), but these day we don&amp;rsquo;t need any JavaScript realy to solve this task. Well, there are two main techniques to handle onClick events in CSS – checkbox-hack and selection by :target. The second way binds our modal window to a URL hash.</description>
    </item>
    
    <item>
      <title>JavaScript MV* Framework - Making the Right Choice</title>
      <link>https://dsheiko.com/weblog/javascript-mv-framework-making-the-right-choice/</link>
      <pubDate>Fri, 06 Jun 2014 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/javascript-mv-framework-making-the-right-choice/</guid>
      <description>JavaScript frameworks have been proliferating recently with a frightening rate. Just take a look at TodoMVC that provides dozens of MV* framework-specific implementation for a single task. It gives a felling how must be confused a developer making a choice for a framework.
Some time ago I even ran into a manifesto (http://bitworking.org/news/2014/05/zero_framework_manifesto) against JavaScript frameworks. I do not completely agree with the author, yet he has a point – it’s too many of them, too many of meta-languages to study that you as a web-developer may not need at all.</description>
    </item>
    
    <item>
      <title>Enabling Templates in Client-Side JavaScript with CJSC</title>
      <link>https://dsheiko.com/weblog/the-client-side-templating-with-commonjs-compiler/</link>
      <pubDate>Thu, 27 Mar 2014 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/the-client-side-templating-with-commonjs-compiler/</guid>
      <description>In spite of most server-side languages JavaScript was not designed for templates. Yet we have plenty of template engines for client-side JavaScript now. They allow us processing templates, but what about declaring a template?
As you know JavaScript doesn’t provide a decent way to assign a multiline text to a variable. Well, you can go with string spitted by back-slashes, but in this case a trailing space would break your JavaScript.</description>
    </item>
    
    <item>
      <title>Modular JavaScript in the browser with CommonJS Compiler</title>
      <link>https://dsheiko.com/weblog/modular-javascript-in-the-browser-with-commonjs-compiler/</link>
      <pubDate>Thu, 23 Jan 2014 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/modular-javascript-in-the-browser-with-commonjs-compiler/</guid>
      <description>JavaScript was designed as a script language that is easy to embed in a larger host system and meant to manipulate the objects of the host system. With the advance of HTML5 formerly mostly static web-pages are turning into sophisticated web-applications. Now we expect JavaScript code to be scalable and modular. But how when JavaScript has no built-in facilities to combine distinct scripts?
Surely, you can insert a script element into the DOM and therefore have outer scripts loaded dynamically.</description>
    </item>
    
    <item>
      <title>Mastering Responsive Web Design with HTML5</title>
      <link>https://dsheiko.com/weblog/responsive-web-design-with-html5/</link>
      <pubDate>Thu, 31 Oct 2013 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/responsive-web-design-with-html5/</guid>
      <description>Bobby Solomon, from the Disney team, stated last year: &amp;ldquo;Honestly, our team is bored of talking about responsive design. It&amp;rsquo;s how any self-respecting website should behave in 2012&amp;rdquo;. Well, responsive web design (RWD) is no panacea, but definitely that is an indicator of good quality in the times when diversity of access point devices steady grows. If simply put, RWD is a way to provide a decent user experience (UX) on a web-site agnostic to the devices or platform it is accessed from.</description>
    </item>
    
    <item>
      <title>Seamless Development: Mastering Live Reload</title>
      <link>https://dsheiko.com/weblog/tooling-live-reload-for-multi-tasked-cycles/</link>
      <pubDate>Thu, 25 Jul 2013 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/tooling-live-reload-for-multi-tasked-cycles/</guid>
      <description>We all are taught not to repeat ourselves while coding. Nonetheless we keep repeating the same operation over and over – pressing F5/Ctrl-R for browser reload every time we have to examine the results of our last changes. After watching some of Paul Irish screencasts where he was showing the magic of live reload under Sublime Text 2 I wondered if I could employ something alike while keeping working with my beloved NetBeans IDE.</description>
    </item>
    
    <item>
      <title>Importing External Files in JavaScript</title>
      <link>https://dsheiko.com/weblog/importing-external-files-in-javascript/</link>
      <pubDate>Wed, 15 May 2013 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/importing-external-files-in-javascript/</guid>
      <description>As JavaScript application grows, navigation on the code becomes a hell. It comes on mind how useful would be to have ability including JavaScript files. For example, thanks to include/require statements we can build an expressive file structure in PHP. Let’s say following PSR-0 standard we have one class per file (or one prototype object per file in JavaScript) and class name (namespace) reflects the location of the file where it belongs.</description>
    </item>
    
    <item>
      <title>Mastering HTML5 Forms: Validation, Inputs, and Beyond</title>
      <link>https://dsheiko.com/weblog/making-use-of-html5-form/</link>
      <pubDate>Wed, 27 Mar 2013 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/making-use-of-html5-form/</guid>
      <description>Since the very beginning of HTML there were no much of changes regarding forms until recently. Yet, there was an attempt to bring a new API with XForms, but it was never really supported by any of major browsers. Now we have a comprehensive consistent Form API which allows us to create full-fledged forms even with not help of JavaScript. Everything sounds so exciting until you try to use HTML 5 Forms on real projects.</description>
    </item>
    
    <item>
      <title>Google Analytics in Your App: Unlock Insights Without Leaving Your Dashboard</title>
      <link>https://dsheiko.com/weblog/bringing-google-analytics-reports-to-your-application/</link>
      <pubDate>Mon, 18 Mar 2013 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/bringing-google-analytics-reports-to-your-application/</guid>
      <description>Reasonably statistic analyses belong to CMS ACP reports. So, CMS vendors tend to include some into their products. However, they often make statistical data collection and analysis a part of CMS. It usually gains some primitive reports and affects application performance. I believe any sound statistic analysis can be delivered only by a dedicated specialized application. Meantime CMS can be used to represent the reports prepared by that application. Have you ever fancied displaying Google Analytics Reports in your CMS?</description>
    </item>
    
    <item>
      <title>JavaScript Asynchronous Dependency Loader</title>
      <link>https://dsheiko.com/weblog/javascript-asynchronous-dependency-loader/</link>
      <pubDate>Tue, 12 Mar 2013 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/javascript-asynchronous-dependency-loader/</guid>
      <description>A substantial web application doesn&amp;rsquo;t need to wait until all the required JavaScript libraries loaded. Usually most of them can load asynchronously and start acting whenever they are ready. Most commonly used approach here would be AMD. That&amp;rsquo;s a sophisticated and time-proved solution. However to use it with libraries, you must have them converted to modules. I don&amp;rsquo;t appreciate the idea to interfere with 3-rd party library code. At the same time I still need non-blocking loading and dependency being resolved in my code.</description>
    </item>
    
    <item>
      <title>Harmony with TypeScript</title>
      <link>https://dsheiko.com/weblog/harmony-with-typescript/</link>
      <pubDate>Fri, 16 Nov 2012 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/harmony-with-typescript/</guid>
      <description>On the way to harmony Not so long ago Microsoft announced a new language, targeting on front-end developers. Everybody&amp;rsquo;s first reaction was like &amp;ldquo;Why on Earth?!&amp;rdquo; Is it just Microsoft darting back to Google? Is that a trick to promote their Visual Studio?
But anyway, what&amp;rsquo;s wrong with JavaScript? Why everybody is so keen to replace it? JavaScript for a language designed in only 2 weeks is freakishly powerful and flexible.</description>
    </item>
    
    <item>
      <title>Review: PHP Application Development with NetBeans</title>
      <link>https://dsheiko.com/weblog/review-php-application-development-with-netbeans/</link>
      <pubDate>Thu, 15 Nov 2012 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/review-php-application-development-with-netbeans/</guid>
      <description>Recently I&amp;rsquo;ve laid my hands on a copy of [&amp;ldquo;PHP Application Development with NetBeans&amp;rdquo; by M A Hossain Tonu](http://www.amazon.com/gp/product/1849515808 &amp;ldquo;&amp;ldquo;PHP Application Development with NetBeans&amp;rdquo; by M A Hossain Tonu&amp;rdquo;) (www.PacktPub.com). It appeared to be a really nice reading. One of those where it&amp;rsquo;s hard to put the book down until the end. It must be valuable as for beginners as for experienced NetBeans users. I, personally, have been using NetBeans for about 4 years and still find in the book the features I wasn&amp;rsquo;t aware about or unfairly ignored for so long.</description>
    </item>
    
    <item>
      <title>Optimizing Mobile Navigation: A Smooth UX for Small Screens</title>
      <link>https://dsheiko.com/weblog/tuning-navigation-for-mobile-devices/</link>
      <pubDate>Sat, 27 Oct 2012 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/tuning-navigation-for-mobile-devices/</guid>
      <description>Making design responsive means not only certain representations on different screens, but also particular behavior on different devices. Usually on mobile devices mouse is not available, keyboard with navigation keys is out of reach. So we are short of controls to provide a useful navigation.
Image viewer Let’s take image viewer. User taps a thumbnail and gets an overlay with the image. We don’t have much screen space on the smartphone.</description>
    </item>
    
    <item>
      <title>My lovely Mac OS X web-development environment</title>
      <link>https://dsheiko.com/weblog/my-lovely-mac-os-x-web-development-environment/</link>
      <pubDate>Mon, 15 Oct 2012 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/my-lovely-mac-os-x-web-development-environment/</guid>
      <description>A few months ago I bought a new Macbook. I’m really fond of the development environment I set up on it. The more I work with it, the more I love it. However, while building the environment I couldn’t find any decent step-by-step manual. So, it took me for a while to get what I wanted. Here’s my experience.
Front-end environment For the beginning we need a package manager. Here arises the first question: which manager is the best to use Homebrew, MacPorts, Fink or Rudix?</description>
    </item>
    
    <item>
      <title>Getting started with TypeScript</title>
      <link>https://dsheiko.com/weblog/getting-started-with-typescript/</link>
      <pubDate>Fri, 12 Oct 2012 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/getting-started-with-typescript/</guid>
      <description>After Microsoft released TypeScript I took a look at their examples and found the idea pretty promising. I do love JavaScript. However, it has its bad parts. JavaScript doesn’t provide any built-in facilities to declare interfaces or object abstraction. There is no explicit way to have type annotations and type checking. Well, even class-based OOP is not a part of the language. Flexibility of JavaScript is incredible. So, there are tons of libraries meant to work-around these inconveniences.</description>
    </item>
    
    <item>
      <title>10 things you need to know about JavaScript</title>
      <link>https://dsheiko.com/weblog/learning-javascript-from-the-code/</link>
      <pubDate>Tue, 10 Jul 2012 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/learning-javascript-from-the-code/</guid>
      <description>Back in 1995 Netscape wanted a language with a simple programming model, but flexible enough for building real scalable applications. Curious, that Brendan Eich accomplished the task in a few weeks. So, we have JavaScript which seems so simple that many people don&amp;rsquo;t even bother to learn the language while using it. And yet it works! However, it turned out to be one of the reasons why JavaScript was dramatically misunderstood .</description>
    </item>
    
    <item>
      <title>Functional testing with qUnit</title>
      <link>https://dsheiko.com/weblog/functional-testing-with-qunit/</link>
      <pubDate>Tue, 03 Jul 2012 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/functional-testing-with-qunit/</guid>
      <description>Automated testing is an essential part of application life-cycle (see Continuous Integration). In web-development we usually test: Back-end (*Unit-tests), Front-end (HTML/CSS validators, JSLint/JSHint, CSSLint, YSlow etc) and UI (functional testing). Unit-testing (Back-end, Front-end) is about checking if all the application components adhere the technical design requirements. Every unit-test simulates the application environment on which runs. Functional tests are to determine if the application as a whole ecosystem has no flaws. They run on a copy of real application environment and show if everything is ok from user prospective.</description>
    </item>
    
    <item>
      <title>Scalable JavaScript Application</title>
      <link>https://dsheiko.com/weblog/js-application-design/</link>
      <pubDate>Thu, 31 May 2012 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/js-application-design/</guid>
      <description>Make of JavaScript the language you need Any diligent developer is constantly working on improving his or her code. There are plenty of books telling how to make your code better. However most of them use the language of class-based OOP. Reader must have enough of experience to reflect those classical design patterns on JavaScript. Thus, many and many developers give up on the language before mastering its true power.</description>
    </item>
    
    <item>
      <title>Pseudo-classical Inheritance in JavaScript for Modules</title>
      <link>https://dsheiko.com/weblog/prototypal-inheritance-in-javascript-for-modules/</link>
      <pubDate>Thu, 24 May 2012 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/prototypal-inheritance-in-javascript-for-modules/</guid>
      <description>The classical design of object in JavaScript can be expressed like:
var ConstructorFunc = function () { var _privateMember = &amp;#34;private member&amp;#34;; } ConstructorFunc.prototype.publicMember = &amp;#34;private member&amp;#34;; ConstructorFunc.prototype.privilegedMethod = function () { return _privateMember; }; Pretty clumsy, isn&amp;rsquo;t it? I prefer the module design propagated so indefatigably by Addy Osmani (http://addyosmani.com/largescalejavascript/):
var Module = function () { // Constructor&amp;#39;s job var _privateMember = &amp;#34;private member&amp;#34;; return { publicMember : &amp;#34;private member&amp;#34;, privilegedMethod : function () { return _privateMember; } } } It looks much nicer to me.</description>
    </item>
    
    <item>
      <title>Dependency Injection via Factory</title>
      <link>https://dsheiko.com/weblog/dependency-injection-via-factory/</link>
      <pubDate>Sat, 21 Jan 2012 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/dependency-injection-via-factory/</guid>
      <description>You know, when coupling is not loose, components depend too much on each other. It makes your entire architecture fragile and immobile. You can check how loose the coupling is by making a unit test for a component. If you have no problem substituting dependencies by e.g. mock objects then everything is ok. Let take a model class. It depends on DB connection, here \Lib\Db\Adapter\Interface instance. We cannot just create DB adapter instance within model constructor, because it depends on configuration data which doesn&amp;rsquo;t belong to the model.</description>
    </item>
    
    <item>
      <title>Design by Contract and JS</title>
      <link>https://dsheiko.com/weblog/design-by-contract-and-js/</link>
      <pubDate>Thu, 22 Dec 2011 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/design-by-contract-and-js/</guid>
      <description>Related articles: Prototypal Inheritance in JavaScript for Modules and Scalable JavaScript Application Design
Design by contract (DbC) is an approach in application design, which originally came from Eiffel, but now widely used on different languages (particularly in Java). In real world one party (supplier) makes an offer for an agreement (business contract) and another one (client) accepts. The same way can be described relations between objects in software engineering. As a declared agreement is accepted by the client object, the last one is expected to keep its rules.</description>
    </item>
    
    <item>
      <title>Flyweight pattern using Mixins</title>
      <link>https://dsheiko.com/weblog/flyweight-pattern-using-mixins/</link>
      <pubDate>Sun, 18 Dec 2011 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/flyweight-pattern-using-mixins/</guid>
      <description>In my previous article among other patters I was telling about Flyweight. That is about the objects designed so to minimize memory use by sharing as much data as possible with other similar objects. You can find plenty of Flyweight implementation examples in Internet, though it will be mostly variations of Multiton, a collection (map) keeping only instance per every identical object. And I decided to follow that unwritten rule as it seems to be the simplest way to show the idea.</description>
    </item>
    
    <item>
      <title>Design Patterns by PHP and JavaScript examples</title>
      <link>https://dsheiko.com/weblog/design-patterns-by-php-and-js-es5-examples/</link>
      <pubDate>Thu, 15 Dec 2011 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/design-patterns-by-php-and-js-es5-examples/</guid>
      <description>After having your project fully tested, deployed and running, it seems the application architecture is pretty good enough. All the requirements met and everybody is happy. But then as it happens, the requirements change and you, all of sudden, find yourself in the time of troubles. It comes out that some modules easier to hack than to modify. Change of other ones brings endless changes in a cascade of dependent modules.</description>
    </item>
    
    <item>
      <title>Bringing realtime to your web applications</title>
      <link>https://dsheiko.com/weblog/real-time-web-application-architecture/</link>
      <pubDate>Mon, 17 Oct 2011 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/real-time-web-application-architecture/</guid>
      <description>Few years ago only lazy didn’t say about bringing desktop application experience to the web ones. However in reality, it just meant that user actions didn’t always required page reload, but could change page UI dynamically. As for other application events, as a rule they were not handled dynamically.
Well, now you can find more and more web applications acting really like desktop ones. For example, Facebook and G+ have widgets which update automatically.</description>
    </item>
    
    <item>
      <title>Build Your Own Simple Web Form Testing Tool</title>
      <link>https://dsheiko.com/weblog/you-own-simple-tool-to-test-web-forms/</link>
      <pubDate>Fri, 07 Oct 2011 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/you-own-simple-tool-to-test-web-forms/</guid>
      <description>When testing a web-site, nevermind who you are developer or QA-engineer, it happens to you pretty often to fill-in form fields again and again. Boring, stupid work, but how to make sure the form does still work as intended? Some fields added, CAPTCHA was attached, whatever else done –you have to run the test again. Besides, it will be repeated on different browsers. Browser form auto-completion feature helps a bit, but that is not the same as when you have various sets of test-data always ready to apply on a form, isn’t it?</description>
    </item>
    
    <item>
      <title>Support Request Tool like Google Feedback</title>
      <link>https://dsheiko.com/weblog/support-request-tool-like-google-feedback/</link>
      <pubDate>Mon, 19 Sep 2011 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/support-request-tool-like-google-feedback/</guid>
      <description>Have you ever noticed Google+ has an amazing feature called Google Feedback. You click on feedback highlight an area of the site page and getting screenshot with your marking on it sent to the Google support team. If you wonder of having this tool on your own, just take my code and adapt for your requirements.
How to install First of all you have to install server side components for making screenshots ( XServer and CutyCapt).</description>
    </item>
    
    <item>
      <title>WebSockets vs Server-Sent Events vs Long-polling</title>
      <link>https://dsheiko.com/weblog/websockets-vs-sse-vs-long-polling/</link>
      <pubDate>Mon, 05 Sep 2011 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/websockets-vs-sse-vs-long-polling/</guid>
      <description>Apparently social networking is the banner of the nowadays web. Everybody intends bringing some features into his projects. Some of them require immediate notification. That is getting common, if you open a page with upcoming messages (status feed, notification subsystem, friends-list), you expected them being updated as soon as a new message (status, notification, friend-making action) arrives. As you well know, original web design allowed only one-way client-server communication (one requests, another one responds), though now HTML5 working group doing their best to fix it or rather to patch it.</description>
    </item>
    
    <item>
      <title>Review services getting consolidated</title>
      <link>https://dsheiko.com/weblog/review-services-getting-consolidated/</link>
      <pubDate>Thu, 04 Aug 2011 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/review-services-getting-consolidated/</guid>
      <description>I anticipate Google to swallow Review Services market using G+. I hate the idea of somebody having total control on everything, but when I buy a product (any product), I see number of variations from different producers. I want to read some reviews, to see some ratings on products and their producers before picking one. That’s natural. Where to get those? On the site of producer/seller? Oh, please! I would rather not trust them entirely.</description>
    </item>
    
    <item>
      <title>HTML5 Video on iPhone: Challenges and Solutions</title>
      <link>https://dsheiko.com/weblog/html5-video-on-iphone/</link>
      <pubDate>Tue, 17 May 2011 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/html5-video-on-iphone/</guid>
      <description>Enabling your videos for iPhone Safari doesn’t seem as a big deal. You know it supports HTML5 . Besides, you don’t even need to write event handlers and produce a skin by yourself, but only take a ready JS component. Apparently [videojs.com] is getting close to be the most popular one. Though, I personally like [mediaelementjs.com]. It is very simple to use any of them. The only difficulty is to get your videos converted to h.</description>
    </item>
    
    <item>
      <title>When Great Ideas Meet Bad Code: A Look at Drupal</title>
      <link>https://dsheiko.com/weblog/drupal-nice-ideas-and-bad-coding/</link>
      <pubDate>Fri, 15 Apr 2011 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/drupal-nice-ideas-and-bad-coding/</guid>
      <description>Related articles: Drupal Meets MVC: A Smarter Way to Build Websites and Beyond the Basics: Enhancing Drupal’s MVC Architecture
Working with Drupal for half of year and constantly tuning it for better maintainability, code consistency I came to the idea – Drupal is going to be a toy, a pretty popular but only toy, unless they decide to rewrite everything from the scratch. Studying Drupal 7 I find the CMS wasn’t really refactored.</description>
    </item>
    
    <item>
      <title>ECMAScript 5 and JS frameworks</title>
      <link>https://dsheiko.com/weblog/ecmascript-5-and-js-frameworks/</link>
      <pubDate>Mon, 13 Dec 2010 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/ecmascript-5-and-js-frameworks/</guid>
      <description>Standards are being always approved with a slow pace. Though, the features declared in drafts usually find their implementation long before the standard release. Let’s take for an instance Websockets, which were already implemented in Chrome/Safari and Firefox 4b when standard unexpectedly changed. Apparently YUI3 and jQuery have implemented for long time the features, which are only coming up with ECMAScript 5 (the implementations is called JavaScript 1.8.5) spread.
YUI 3 from the very beginning introduced controllable attributes.</description>
    </item>
    
    <item>
      <title>Beyond the Basics: Enhancing Drupal’s MVC Architecture</title>
      <link>https://dsheiko.com/weblog/extending-mvc-on-drupal/</link>
      <pubDate>Wed, 10 Nov 2010 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/extending-mvc-on-drupal/</guid>
      <description>Related articles: Drupal Meets MVC: A Smarter Way to Build Websites and When Great Ideas Meet Bad Code: A Look at Drupal
I’ve already described an approach of using MVC in Drupal . It wasn’t bad for the beginning I hope. Though in real life you face requirements which hardly can be fulfilled with such a simplicity. In, more or less, complex application you ain’t going to be satisfied by the only controller (page controller) to serve the whole bunch of components presented on the page.</description>
    </item>
    
    <item>
      <title>Customizing phpBB3 the Smart Way: Feature-Driven Configuration</title>
      <link>https://dsheiko.com/weblog/phpbb3-customization-driven-by-configurable-feature-list/</link>
      <pubDate>Tue, 26 Oct 2010 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/phpbb3-customization-driven-by-configurable-feature-list/</guid>
      <description>Let’s assume you have installed phpBB3 to run forums on the web-project you are working on. It can be a Drupal-based site using phpBBforum Integration module . Anyway, the forum system was re-skinned and your project manager, seems, is pretty happy for the first. But later he requests some changes, e.g. to prevent users from sending emails to each other within the board. This one is easy; you can just direct him to ACP / General / E-mail settings, where board-wide emails can be disabled globally.</description>
    </item>
    
    <item>
      <title>Drupal Meets MVC: A Smarter Way to Build Websites</title>
      <link>https://dsheiko.com/weblog/building-a-site-on-drupal-using-mvc/</link>
      <pubDate>Thu, 01 Jul 2010 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/building-a-site-on-drupal-using-mvc/</guid>
      <description>Related articles: Beyond the Basics: Enhancing Drupal’s MVC Architecture and When Great Ideas Meet Bad Code: A Look at Drupal
If you ought to build a new site and don’t have time to develop a CMS, you’ll likely take an open source solution. And likely it will be Joomla or Drupal. They seem as most popular. Actually they are similar in many ways. Both provide basic content management frameworks, extensible through plug-ins and customizable via themes.</description>
    </item>
    
    <item>
      <title>MVC on command line</title>
      <link>https://dsheiko.com/weblog/mvc-on-command-line/</link>
      <pubDate>Tue, 15 Jun 2010 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/mvc-on-command-line/</guid>
      <description>If you work with Zend Framework, you likely tried ZF Console (Zend_Tool on command line). But have you tried to extend it? Why? To have common interface for all your Cli-scripts related to ZF-base project. How do you find the idea to program Cli-scripts in MVC? Zend Framework provides us with the tool to do it.
First, you have to make ZF shell script zf.sh and assisting zf.php globally accessible. Wherever you have located them, just make a symlink on zf.</description>
    </item>
    
    <item>
      <title>Real-Time Updates with HTML5: Unlocking Server-Sent Events</title>
      <link>https://dsheiko.com/weblog/html5-and-server-sent-events/</link>
      <pubDate>Thu, 10 Jun 2010 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/html5-and-server-sent-events/</guid>
      <description>Related articles: Bringing realtime to your web applications and WebSockets vs Server-Sent Events vs Long-polling
Besides, already noted bidirectional communication channel, known as WebSocket, HTML5 propositions include also comet communication pattern by defining Server-Sent Events (SSE). WebSocket widely discussed by now, tons of server implementations are available and you can play already with fluent browser implementation under Chrome. However the second server-push technology of HTML5 yet stays in shadow.
We are used to consider the HTTP protocol as request-response model, which means that the client sends a HTTP request and waits until the HTTP response is received.</description>
    </item>
    
    <item>
      <title>Mastering i18n: Internationalizing Dynamic UIs with Ease</title>
      <link>https://dsheiko.com/weblog/i18n-for-dynamic-ui/</link>
      <pubDate>Fri, 28 May 2010 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/i18n-for-dynamic-ui/</guid>
      <description>Since YUI 3.1 version, the framework includes internationalizing utility. That’s pretty huge from the prospective of application maintenance and deserves a little review.
String translation The Yahoo team intended to bring into the library some ideas from Java internationalization experience. Particularly Yahoo Resource Bundles based on idea of Java property files. So, translation of an application can be achieved the following way:
First, YRB is created. That can be a JSON-formatted file of .</description>
    </item>
    
    <item>
      <title>YUI3 vs jQuery</title>
      <link>https://dsheiko.com/weblog/yui3-vs-jquery/</link>
      <pubDate>Fri, 28 May 2010 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/yui3-vs-jquery/</guid>
      <description>Everybody time to time comes to the dilemma which JS library to choose for further development. I used to work with prototype coupled with script.aculo.us and now use YUI3 in the office and jQuery at home. I like both of them, though finding each as the best one &amp;lsquo;sui generis&amp;rsquo;. YUI3 is a classical framework that provides design patterns and development philosophy as well as tool. jQuery is meant as a rapid, lightweight, flexible and pretty easy to start library.</description>
    </item>
    
    <item>
      <title>From Chaos to Control: Improving Your PHP Error Handling Workflow</title>
      <link>https://dsheiko.com/weblog/error-handling-for-your-php-application/</link>
      <pubDate>Wed, 26 May 2010 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/error-handling-for-your-php-application/</guid>
      <description>However fondly you treat your application, errors happen and they happen often when it is being developed. That’s obvious you want to get all the tracing information during the development stage and something like ‘Application Error’ page if the error occurs on the production.
Everybody knows error handler can be set in PHP through set_error_handler. The same about exceptions for which set_exception_handler is used. But it really works only for user-defined errors and uncaught exceptions.</description>
    </item>
    
    <item>
      <title>Anonymous Functions and Closures in PHP</title>
      <link>https://dsheiko.com/weblog/anonymous-functions-and-closures-in-php/</link>
      <pubDate>Fri, 21 May 2010 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/anonymous-functions-and-closures-in-php/</guid>
      <description>If you are used to switch between JS and PHP programming, it obviously happened to you to miss some of JS flexibility in PHP. I felt it every time when declaring a callback function , being eager to apply something from JS like that:
var scope = &amp;#39;internal&amp;#39;; setTimeout(_callback, 100); // Callbacks var _callback = function() { alert(scope); } And when I needed a recursive use, even like that:
(function(delay){ timer = setTimeout(function(){ timer = setTimeout(arguments.</description>
    </item>
    
    <item>
      <title>Source Code Analysis: Code Sniffer</title>
      <link>https://dsheiko.com/weblog/source-code-analysis-code-sniffer/</link>
      <pubDate>Thu, 20 May 2010 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/source-code-analysis-code-sniffer/</guid>
      <description>Choice problem In the previous article we examined the only way of code analysis – PHP tokinizer. But digging deeper you’ll find many of options. Well-known expert of the subject Sebasitan Bergmann points out following
Dynamic code analysis -* Xdebug (can be coupled with PHPUnit) -* php-code-coverage Static code analysis -* Token-Level Analysis by ext/tokenizer and PHP_TokenStream -* Syntax-Level Analysis by PHP_Reflection_AST and ext/parse_tree -* Bytecode-Level Analysis by ext/bytekit As far as you see, with such a set of tools you can do whatever you want.</description>
    </item>
    
    <item>
      <title>Image Slider: Comparing JS, JQuery and YUI3 Implementations</title>
      <link>https://dsheiko.com/weblog/image-slider-comparing-js-jquery-and-yui3-implementations/</link>
      <pubDate>Fri, 14 May 2010 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/image-slider-comparing-js-jquery-and-yui3-implementations/</guid>
      <description>Here lies the story… First I decided rewrite my old BlogSlideShow JS-class. In fact I have a plan to rewrite all of my old works gaining to update functionally and appearance regarding to nowadays fashion and make better their code. You can see what I got at the demo page. So, after I finished with implementation on fluent JS, without use of any external library I ported it on jQuery. After that I wrote also implementation on YUI3.</description>
    </item>
    
    <item>
      <title>From Code to Content: Measuring Translation Coverage in Your Project</title>
      <link>https://dsheiko.com/weblog/source-code-analysis-translation-coverage/</link>
      <pubDate>Mon, 10 May 2010 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/source-code-analysis-translation-coverage/</guid>
      <description>How to Make Translation Term Coverage Report Let’s assume our application has a UI translation module. We created dictionary and use terms from there within the code of application components. Everything is clear so far. But one day we begin to suspect that not all of the terms presented in the dictionary are really used within the application. Besides, probably some of terms which are used in components are not available in the dictionary.</description>
    </item>
    
    <item>
      <title>Persistent Full Duplex Client-Server Connection via Web Socket</title>
      <link>https://dsheiko.com/weblog/persistent-full-duplex-client-server-connection-via-web-socket/</link>
      <pubDate>Wed, 05 May 2010 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/persistent-full-duplex-client-server-connection-via-web-socket/</guid>
      <description>RIA is considered as one of the mostly particular to the modern Web feature, and often stands for the trend, according to which web-applications tend to desktop applications. Nonetheless the approach is very relative. Overwhelming majority of “rich” web-applications is still built on the “request-response” model. I.e. events of the client side can be reflected on the sever side, but not vice-versa. In order to make such a trivial thing as a chat, you have to go with tricks.</description>
    </item>
    
    <item>
      <title>Sapid CMF reload</title>
      <link>https://dsheiko.com/weblog/sapid-cmf-reload/</link>
      <pubDate>Fri, 30 Apr 2010 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/sapid-cmf-reload/</guid>
      <description>Eventually I reincarnated my personal site using alpha version of Sapid CMF 2. I’m still in progress refining the CMS release, but actually the only what I brought from old version is its name. So, what is going to be? First of all that’s a new explicit architecture. According to the request dispatcher finds controller. The controller using services prepares data for the view. Services access raw data via DAOs, which respectively use DTOs (Data Transfer Objects).</description>
    </item>
    
    <item>
      <title>Feature Driven Development for web-developers</title>
      <link>https://dsheiko.com/weblog/feature-driven-development-for-web-developers/</link>
      <pubDate>Mon, 22 Dec 2008 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/feature-driven-development-for-web-developers/</guid>
      <description>About 10 years ago web-projects were mostly static and development process pretty simple. Now difference between web-applications and desktop applications disappears, functional complexity of web-projects grows up. It demands to new requirements. That’s usual now – the project is long-term , many of experts take part (non-experts as well). Everybody brings to the project backlog new ideas and goals, before the development stage as well as after. You see, goals and stories mutate and so the tasks.</description>
    </item>
    
    <item>
      <title>How to Create Facebook Applications</title>
      <link>https://dsheiko.com/weblog/how-to-create-facebook-applications/</link>
      <pubDate>Tue, 06 May 2008 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/how-to-create-facebook-applications/</guid>
      <description>What makes sense in writing of Facebook applications Has it ever occurred to you to fancy about all Facebook applications are simple and similar per se? All of these virtual hugs, gifts, greeting cards, wishes, likenesses, poke, smiles, karma-exchange and other psychological “stroking” differ only with the form, in which user get their portion of attention. Thus this niche is always open for persons interested to test their own ideas. Facebook applications enroll the audience in the way viral marketing works.</description>
    </item>
    
    <item>
      <title>Discover a World of Fascinating People. Popularly about social networking</title>
      <link>https://dsheiko.com/weblog/popularly-about-social-networking/</link>
      <pubDate>Tue, 12 Feb 2008 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/popularly-about-social-networking/</guid>
      <description>It is common to encounter success stories that begin with the words: “I’ve have been lucky in my life. I’ve made good friends and met like-minded people who have helped me from the beginning. Thanks to them I have achieved my dreams”. It is evident that not everyone reaches their goals and not everyone us is lucky enough to meet people who can direct their life towards success. The Internet epoch has introduced a tremendous new option in the realm of communication.</description>
    </item>
    
    <item>
      <title>Tendencies in Content Management Software Development or CMS 2.0</title>
      <link>https://dsheiko.com/weblog/tendencies-in-content-management-software-development-or-cms-2-0/</link>
      <pubDate>Wed, 21 Nov 2007 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/tendencies-in-content-management-software-development-or-cms-2-0/</guid>
      <description>Opinions on the future of Web 2.0 differ, and sometimes a lot, but no one would argue that this concept in many ways shaped the present-day Internet. That is why we, developers, should follow new tendencies and trends on the market. Web 2.0 brings with it new requirements.
Consumers of CMS-based solutions largely fall into three categories: corporate users, internet users and third-party applications. The first two categories include people, and over the time we have developed following preferences:</description>
    </item>
    
    <item>
      <title>Communities 2.0 or The Architecture of Participation</title>
      <link>https://dsheiko.com/weblog/communities-2-0-or-the-architecture-of-participation/</link>
      <pubDate>Tue, 27 Feb 2007 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/communities-2-0-or-the-architecture-of-participation/</guid>
      <description>Today there’s no lack of reports on successful Web 2.0 community projects(1). This is by no means surprising as the latest community projects provide advanced interactive experience for the audience while attracting impressive investments. This results in rapid growth within the market segment and businessmen rush in to get their share of the deal. The market now offers a huge number of solutions, and some of them seem to be of quite agreeable quality.</description>
    </item>
    
    <item>
      <title>E-Business 2.0</title>
      <link>https://dsheiko.com/weblog/e-business-2-0/</link>
      <pubDate>Wed, 21 Feb 2007 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/e-business-2-0/</guid>
      <description>What do we know about e-business? Can we consider a corporate site a form e-business? And what about an internet-store? Try a search by any of the popular engines and you will learn a lot about e-business centers but much less about e-business as such. Most web-developers still fail to offer anything beyond the very conventional solutions: official web-site, catalogue, online store, etc. But is that really enough to develop effective e-business solutions?</description>
    </item>
    
    <item>
      <title>Rich Internet Applications and Content Management</title>
      <link>https://dsheiko.com/weblog/rich-internet-applications-and-content-management/</link>
      <pubDate>Mon, 19 Feb 2007 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/rich-internet-applications-and-content-management/</guid>
      <description>Today everyone talks about Web 2.0. But while the idea of a collective intelligence, implied here by the term&amp;rsquo;&amp;rsquo;s inventor Tim O&amp;rsquo;&amp;lsquo;Reily remains an object of trivial speculations, it is obvious that the World Wide Web is changing. Web applications are increasingly approaching the level of functionality, which is usually found only in desktop applications. And as this trend is gaining momentum, we can already witness the dawn of a new era brought about by a novel kind of web applications - Rich Internet Applications (RIA).</description>
    </item>
    
    <item>
      <title>Aspect-oriented Software Development and PHP</title>
      <link>https://dsheiko.com/weblog/aspect-oriented-software-development-and-php/</link>
      <pubDate>Wed, 08 Nov 2006 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/aspect-oriented-software-development-and-php/</guid>
      <description>Introduction Object oriented approach has been popular for a number of years. Its advantages can hardly be visible within short-term projects, yet any major long-term one simply cannot do without it. Object-oriented programming languages provide the tools necessary to present business logic in a demonstrable form. Today UML Class diagram (http://en.wikipedia.org/wiki/Unified_Modeling_Language) does suggest itself even on the stage of developing the system logic.
Demonstrable business logic makes it easier for new participants to join in, helps to save time for those developers that come back into the project at later stages.</description>
    </item>
    
    <item>
      <title>How to Make AJAX  Read between the Lines</title>
      <link>https://dsheiko.com/weblog/how-to-make-ajax-read-between-the-lines/</link>
      <pubDate>Fri, 24 Feb 2006 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/how-to-make-ajax-read-between-the-lines/</guid>
      <description>Your site may contain a wealth of technical terms. The user while viewing it may have to wonder about their meaning. What can be done to provide site visitors with instant answers to the questions they have? Previously technical terms were represented as links so that users could click them and get a definition window. This approach, however, is rather clumsy and time-consuming: one has to click the link, wait for the definition window to load and then close it.</description>
    </item>
    
    <item>
      <title>Interactive Grid with Your Own Hands</title>
      <link>https://dsheiko.com/weblog/interactive-grid-with-your-own-hands/</link>
      <pubDate>Fri, 17 Feb 2006 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/interactive-grid-with-your-own-hands/</guid>
      <description>I am sure being accustomed to desktop applications GUI, users find interfaces of web-applications as extremely uncomfortable. Their notes, probably unexpressed, are timely within AJAX Age. Besides, it is not so difficult to make web-applications more user-friendly. I will not describe whole variety of interface forms in this article, but will concentrate on such an indispensable element as a grid. Almost every web-application needs linear data list management. DB record management of PhpMyAdmin is likely a classical solution in this field.</description>
    </item>
    
    <item>
      <title>What is XML Sapiens?</title>
      <link>https://dsheiko.com/weblog/what-is-xml-sapiens/</link>
      <pubDate>Fri, 17 Feb 2006 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/what-is-xml-sapiens/</guid>
      <description>Vignette company presented the first commercial solution of CMS (Content Management System) class in 1995. Since then the number of commercial CMSs is diligently growing up and the CMS term settled down on the market. Many of open standards have been approved lately. They allow to structure information within sites, separate it from design, but the most of CMSs still don&amp;rsquo;t follow them. The XSLT standard exists for quite a long time.</description>
    </item>
    
    <item>
      <title>Data, its presentation and user interface forms</title>
      <link>https://dsheiko.com/weblog/data-its-presentation-and-user-interface-forms/</link>
      <pubDate>Sat, 12 Feb 2005 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/data-its-presentation-and-user-interface-forms/</guid>
      <description>XML has acquired a distinguished popularity lately. No one doubts its perspectives of overall use. The concept of semantic web is no longer an abstraction and is implemented into life with confidence. In the world net&amp;rsquo;s information cacophony there appears harmony. In the hands of talented conductors such as W3C, ISO, OASIS it can diversify into a symphony.
Today XML family has so many standards available that it seems there should be quite enough for all possible aspects of information technology world.</description>
    </item>
    
    <item>
      <title>XML Sapiens is a tool to divide site functionality and program core</title>
      <link>https://dsheiko.com/weblog/xml-sapiens-is-a-tool-to-divide-site-functionality-and-program-core/</link>
      <pubDate>Sun, 05 Dec 2004 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/xml-sapiens-is-a-tool-to-divide-site-functionality-and-program-core/</guid>
      <description>Each minute the amount of content in the Web is surging up. This tendency is getting more and more intensive. As a result, tough competition makes web site-builders develop complicated interfaces to content. New generations of Content Management Systems (CMS) are replacing one another with impressive dynamics. Modern solutions require brand-new features, unavailable in the recent past. Tomorrow they&amp;rsquo; will need features, which are not available today. The question “How do I save my investment to web development?</description>
    </item>
    
    <item>
      <title>How to make own CMS</title>
      <link>https://dsheiko.com/weblog/how-to-make-own-cms/</link>
      <pubDate>Fri, 20 Feb 2004 00:00:00 &#43;0000</pubDate>
      
      <guid>https://dsheiko.com/weblog/how-to-make-own-cms/</guid>
      <description>Every day millions of new web documents emerge on the Internet, and the amount of web management tools is growing simultaneously. These tools are usually referred to as Content Management Systems, CMS for short. If you have a web site and still do not use any CMS, you will definitely face a choice to buy or to develop an enterprise content management solution in the near future. What would you do if you wanted to develop a CMS, your own software that has a WYSIWYG editor and perfectly meets all your requirements and security standards?</description>
    </item>
    
  </channel>
</rss>