As I See Tech

As I See Tech is taking a holiday break, coming back next year. Enjoy the season of caring, giving, loving and sharing. Peace!

I like books. I like owning them. I like reading them. And re-reading them. They're joys to have. Books are bound to be immortal treasures. Digitizing them is cool and nice and stuffs. But nothing beats the pleasure of experiencing books in print, hardbound, paperback and all.

Biometric authentication is not mainstream. It's expensive. It's hardware specific. It is also not an all-in-one solution. However, if done right, there is a higher chance that the future would be better with it.

Mendz.Graph's Graph class implements IFormattable. The default DOTFormatProvider and DOTFormatter implementations included in Mendz.Graph are really just samples of what can be done. Developers are encouraged to create and use their own IFormatProvider and ICustomFormatter implementations for the Graph.

Not as much fanfare as I expected, but it's finally out! Dapper 1.50.4 for .Net Standard 2.0 is ready! Exciting times ahead for fans of the micro-ORM library.

All Mendz projects and products are now .Net Standard 2.0 class libraries. Use them all in your .Net Core or .Net Framework or .Net Standard targeting projects.

For the longest time, web applications absorb processing loads on the server-side, leaving the client-side to mostly just rendering the response (i.e. HTML/CSS) from the web server. Now, with JavaScript frameworks like Angular, React, Vue, etc., the client-side is sharing the processing load.

When creating ASP.Net applications for business and enterprise requirements, you are more likely doing something nowhere near basic. While simple MVC examples are available everywhere, the truth is, they are more often, if not always, NOT applicable as-is.

What does it take to be a data scientist? What do I need to learn? What skills should I have? What tools should I know?

To those who own game consoles, you know very well why they should last a long time. Unlike smartphones, tablets, laptops and desktops, which have 3 to 5 year life cycles, game console life cycles are estimated at 6 to 8 years. In my opinion, XBox One X just about got it right.

Imagine a future where you can have a single device from which you can choose whichever network carrier/provider is providing the best service and offerings where you are. Imagine carrier competition on steroids. Possible? Perhaps with eSIM, and with prepaid subscriptions the norm.

Apple SIM has gone a long way from just enabling data to now include making and getting calls as exemplified by the new Apple Watch Series 3 . As I See Tech thinks this is big , and you should too!

Apple released the 3rd-generation of the Apple Watch in September 2017. It's available with GPS only or with GPS+cellular via eSIM. This article is interested in the latter, and As I See Tech thinks it's going to be big!

I am pretty much ending the year with a blast! I have finally published my projects in GitHub and NuGet. I am happy with how they are progressing and how they are getting maintained. There are more work up ahead, but mostly it's a celebration to know that they are finally already out there.

Documentation can be a lot of work, but someone has to do it. API with no documentation is like a new invention not explained. Considering, developing codes and tests are even easier than expressing them in a language that most people will understand. Nonetheless, documentation needs to be done and that's the goal for the rest of the year.

If you like Mendz.Matrix and Mendz.Graph, you'll love Mendz.Graph.Representation.

G = (V,E). If that makes sense to you, then Mendz.Graph is for you! If it doesn't make sense to you, and you need to work on graphs (Graph Theory), then Mendz.Graph is definitely for you, too!

Matrix, square matrix, dense matrix, sparse matrix and compressed matrix galore! Create matrices, perform mathematical operations with them, and even compress them using CRS (compressed row storage), CCS (compressed column storage) or CVS (compressed value storage). Mendz.Matrix is a simple and lightweight library for working with matrices.

Mendz.Data is designed with the team in mind. Different developers have different styles. A good team respects each member developer's style. However, a team working on the same project should also mean that all developers agree on many things. At the very least, code completeness, consistency and quality should be predictably maintainable and measureable.

Mendz.Data.* helps teams delegate and separate concerns. Not everything needs to be done in a single project. You can use Mendz.Data to distribute tasks so that deliverables can be created concurrently, tested independently and later assembled/integrated together for functional testing.

The truth is, you can use the Mendz.Data.Repository and Mendz.Data.Repository.Async CRUDS interfaces in your own custom repository implementations. There is nothing in this namespace that requires you to use them only in purely Mendz.Data-based contexts and repositories.

The idea and motivation behind Mendz.Data is to remove the abstraction out of project planning, so that you can jump right ahead to coding and development. Mendz.Data is not just a library of APIs. As advertised, it is designed to provide tools and guidance.

More than a month has passed since I published Mendz.Data. Many developers and teams are using Mendz.Data to guide them in developing contexts and repositories for their projects. Simplicity, consistency, productivity, quality and scalability are key motivators.

Advanced ETL requirements can involve building data from various sources. Mendz.ETL-based joiners allow developers to define advanced query operations on data sources, generating data into a desired format that can be better consumed by the ETL flow.

ETL involves agreements between partners with regards to how they will "speak" with each other. Validating what a partner sends and what you send to your partner is an important ETL requirement. Mendz.ETL supports the creation of validators, which can be called at the start and at the end of an ETL flow.

Mendz.ETL suggests three basic ingredients to ETL solutions: source adapter, mapper and target adapter. Here are some ideas for your target adapters.

Mendz.ETL suggests three basic ingredients to ETL solutions: source adapter, mapper and target adapter. Here are some ideas for your mappers.

Mendz.ETL suggests three basic ingredients to ETL solutions: source adapter, mapper and target adapter. Here are some ideas for your source adapters.

The first thing you need to know about Mendz.ETL is that, by itself, it does nothing. After all, Mendz.ETL is just a library of APIs. What do you expect? However, what you create with Mendz.ETL, the adapters, mappers, validators and joiners you invent with it, those will do something. And, together, they can be big.

I am very excited to announce Mendz.ETL, a class library that provides APIs to let you create custom/proprietary extract, transform and load (ETL) solutions.

Mendz.Library v1.2.1 introduces MapperExtensions for the IGenericMapper and IStreamingMapper interfaces. IGenericMapper and IStreamingMapper can help in creating consistent data mapping codes and strategies. MapperExtensions adds a couple of features that aim for the same.

Mendz.Library is my class library project for anything that can be used shared and used by various projects. Version 1.2.1 adds new classes, types and extensions that can help spark new ideas and inspirations. Here are the highlights.

Welcome to the new As I See Tech. Well, actually, I've been using this Contempo theme for weeks now. I originally only wanted to test it out for a bit. The way things are, I think that it's working pretty well.

In Mendz.Data.Repository(.Async) CRUDS interfaces, one of the method parameters is "dynamic expansion = null". You may be wondering, what it is? What's it for? Or perhaps even asking why? Well, it's really nothing... until you need to use it. And it can be one of the most powerful features of Mendz.Data.Repository(.Async)'s CRUDS interfaces.

Mendz.Data.ResultInfo is like a POCO of result information. When used with ADO.Net compatible contexts (like those based on Mendz.Data.Common.DbDataContextBase), ResultInfo can be handy in saving input and output values for the caller. Mendz.Data.Common.ResultInfoExtensions provide a couple of useful shortcuts.

There are always cleaner and simpler ways of doing things. This topic is a matter of preference. Consider this approach to clean out some lines of codes from your ASP.Net application's controllers.

Class libraries are meant to be shared. It can be used by web applications. It can be used by services. It can be used by batch programs. With that in mind, it is important to think about contexts and repositories as class libraries, that are meant to be re-used and shared by your current application project and by your future application projects.

ADO.Net provides the basic data access capabilities of .Net. Even with the Entity Framework around, ADO.Net remains solid. Just like how the very basic concept of the typewriter remains alive in our keyboards, ADO.Net is here to stay. Mendz.Data.Common embraces this assumption as fact, in order to provide the APIs needed for creating contexts and repositories.

Mendz.Data.MongoDB, which provides a generic Mendz.Data-aware context for MongoDB, is now on GitHub and NuGet!

The Mendz.Data.Common namespace provides the APIs needed to create Mendz.Data-aware contexts and repositories. Here's to understanding the main classes and types in this namespace.

Mendz.Data.PagingInfo represents paging information. The idea is to basically have a POCO that can be used to store and exchange paging data that can be used by backend queries, by middlewares and by frontend rendering codes.

The rational behind Mendz.Data's DataSettings and DataSettingOptions is simple: provide an easy way to get data settings, like connection strings, anywhere during the application's runtime. Note that .Net Core 2.0's configuration and dependency injection features make this possible. DataSettings and DataSettingOptions provide an alternative.

ResultInfo represents result information about a procedure call. It can store the input and output values. These information can be used, for example, to build messages after an operation or a series of operations completed. These messages can be used for logging, or for alerts and notification.

Mendz.Data.Repository defines the CRUDS interfaces. Mendz.Data.Repository.Async defines the async versions of the CRUDS interfaces. The new CRUDS signatures add more features and flexibility. Here are the highlights.

If you followed my Dapper series back in May/June this year, you should know that Mendz.Data 1.1.0, as published in GitHub and NuGet , has major breaking changes. For starters, the new Mendz.Data is a .Net Standard 2.0 class library. Internally, there's more.

I originally thought I needed Mendz.Data.EntityFramework. After some minor re-design and simplification, I realized that all I really needed was just Mendz.Data. Immediately, Mendz.Data.EntityFramework became obsolete.

Mendz.Data.SqlServer, which provides a generic Mendz.Data-aware context for ADO.Net-compatible access to SQL Server databases, is now on GitHub and NuGet!

Mendz.Data, which provides tools and guidance for creating data access contexts and repositories, is now on GitHub and NuGet!

In Mendz.Library, one of the classes defined is the SingletonBase. The SingletonBase is an abstract or base class for defining singletons. The singleton instantiation is aimed to be thread-safe. Let's look at how it's done.

In Mendz.Library, one of the classes defined is the IDGenerator. The IDGenerator is a thread-safe generator of incremental integer values. It can be seeded to start from a seed number and increment from there. Simple right? Let's look at how it's done.

Publishing to NuGet is quick and easy. Visual Studio 2017 has the basic tools available to create NuGet packages. Just follow the steps, upload and you're good!

Publishing source codes to GitHub is not that difficult. It took me a while to get the gist of it. In the end, the real saving grace is the decision to NOT use Visual Studio Team Services tools and to use GitHub Desktop instead.

I did the basics. I followed the steps. Finally, I have my first library project published to both GitHub and NuGet. Mendz.Library 1.0.0 is now live!

However beautiful your app's user interface (UI) can be, it means nothing until the user experience (UX) defines it.

When I ask the question "Is Microsoft Fluent Design System the Next Aero?", I mean it in a very daunting way. What I really mean to ask is if Microsoft Fluent Design System would suffer the same fate as the Windows Aero? Crass, I know. But possible? Yes.

Windows has changed its UI/UX many times over the years. The most successful of these is that from Windows 7, for which many seemed to have associated what a desktop experience should be. Windows 10's MDL/2 is the current "modern" incarnation. A change is coming likely next year, and Microsoft calls it Fluent Design System.

Microsoft's Metro Design Language (MDL) was beautiful. Many of its parts are still in Windows 10 today. However, some of the things that made it great already disappeared. Let's try to analyze them and the reasons why.

When Microsoft released Windows Phone 7, it introduced revolutionary user experiences that are far ahead of its time. Well, "far ahead of its time" meant that the target users were not ready for it. Regardless, Metro UI, as it was called, was beautiful!

Mendz projects are kept in an online Visual Studio Team Services account as a private and personal collection. Switching to GitHub and publishing to NuGet is now an option.

SOAP web services are not first class citizens in .Net Core. Not so long ago, Microsoft so eagerly spent a lot of resources to SOAP-based web services, "sold" it as HTTP+XML and even published a lot of libraries, software factories, guidelines and what have you for it. Now... oh, how times have changed!

Microsoft developed a shim technology to allow .Net Framework compatibility with .Net Standard and .Net Core. Before .Net Standard 2.0, the shim was incomplete. If you have .Net Framework 4.x-based class libraries that you want to share with .Net Core 1.x projects, you can create a .Net Standard 1.x class library project to enable cross-use.

I am currently starting to port my class library projects from .Net Core 1.1 to .Net Standard 2.0. So far, and I am happy to report that, the overall migration experience is a breeze!

In application development, adding security features can include requirements for authentication and authorization. Authentication identifies the user. Authorization checks and filters what the user can do. Authentication is mostly easy. Authorization though can be a little bit tricky.

In a world where everything connects to a cloud hosted OS, IoT can be cheaper and simpler. The real focus is fast and reliable networking, because everything really happens in the cloud.

In a world where everything connects to a cloud hosted OS, the smartphone can be cheaper and simpler. There is no need to make them more powerful than an interactive TV. The real focus is on fast and reliable networking, because everything else really happens in the cloud.

Let's assume for example that the world wide network is giga- or even tera- bits fast and 100% reliable. Imagine the possibilities...

Unlike how Apple iOS and Google Android started, when Microsoft launched Windows for phones, it needed justification.

If there's anything the iPhone X proves, it's the fact that mobile tech innovation has gone stagnant. It's almost like how our cars are mostly still running on fossil fuel, or that they are still rolling on four air inflated rubber tires. The mobile industry has taken its cue from the automobile industry. Just advertise it as new, even if there's really nothing new, and it will still sell as new.

With the release of .Net Core 2.0 comes great responsibility. It is time to review Mendz's .Net Core 1.1-based projects, to see how well they can all be upgraded to the latest version of .Net Core.

.Net Core 2.0 is out! It can be considered the version that we've all been waiting for. The .Net Core has officially matured and it's ready to roll.

Regular expressions provide a powerful language to define patterns that can be used for data matching and searching operations.

Learning how to use regular expressions can give developers power over data when solving problems with pattern matching, searching, format validations and conversion.

In programming, if there's a "language" that's as crazy as speaking in cryptic sequence of symbols, it's regular expressions. Learning how to use regular expressions can be intimidating. However, once you get over the dyslexic looking syntax, you'll be amazed at how powerful it can be in data formatting, matching, processing, searching and validating programs.

Although SQL has been the language of choice for RDMS, it doesn't mean SQL cannot be applicable to NoSQL databases. It's really all about sets. If a collection can be treated as a set, and a collection of collections a set of sets, SQL should be an easy fit.

The people who promote MongoDB are smart. They don't push MongoDB at you. They help you make intelligent decisions. After all, they know MongoDB is new. They don't just recommend migrating your 10+ years old RDMS-based applications to MongoDB. More likely, they would instead recommend that you consider creating new requirements and applications in MongoDB.

Data collection is highly valued. There are businesses focused on profiting from them. Data analysts and data scientists are the new careers to aim for. It's not just about big data anymore. It's now about really putting them to work, with the ultimate manifestation building what is known as artificial intelligence.

Mendz is back and refreshed! As I See Tech continues...

Mendz is on vacation. Enjoy the last few days of summer everyone!

I am a Windows 10 phone user. I own a Nokia Lumia ICON. I love it. With Microsoft seemingly killing off Windows 10 for phones anytime soon, I feel the pain. I probably share the same sentiments as other Windows 10 phone users. Regardless how loyal to the platform we wish to be, it seems inevitable that we shall forever be the last few. Microsoft does not care.

While researching on compressed sparse matrix, I stumbled upon compressed row storage (CRS; compressed sparse row, CSR; Yale format) and compressed column storage (CCS; compressed sparse column, CSC). These sparse matrix compression formats are popular. Stepping back and imagining the possibilities, I considered the possibility of applying basic lossless compression techniques to sparse matrices, exploiting data redundancy, leading to what I call the compressed value storage (CVS) .

Compressed value storage (CVS) applies lossless compression to a matrix resulting to storage that can be smaller than the popular compressed matrix formats like CRS and CCS. In Visualizing Compressed Value Storage (CVS), I described an imagination of using CVS to store and render images. The overall idea is simple. In fact, it's so simple that it seems possible to implement the idea using JSON and HTML5 canvas.

This article describes an imagination of compressed value storage (CVS) being used in graphics storage and rendering. The imagination does not make any assumption that CVS can really be used for digital images. This is basically a spill of thought processes and no codes or implementations are shared. Still interested? Read on...

CVS is coordinate-wise in many ways. However, some operations are challenging. Performing CVS-to-CVS multiplication is possible but with a catch (at least as of this writing). CVS's own rule about keeping distinct non-zero values and aligning their lists of linear indexes creates a challenge when performing operations that can create zeroes or repeating values.

CVS is coordinate-wise in many ways. However, some operations are challenging. Performing CVS-to-CVS addition/subtraction is possible but with a catch (at least as of this writing). CVS's own rule about keeping distinct non-zero values and aligning their lists of linear indexes creates a challenge when performing operations that can create zeroes or repeating values.

The compressed value storage (CVS) is new. I say that because I can't find materials about it or something similar to it online. Or perhaps I am searching with the wrong keywords. Basically, my problem is that there is not much to find about how CVS can be used in matrix operations. So, for now, I have to figure things out on my own.

My current study is to add more features/methods for the compressed value storage (CVS) format. CVS is a lossless compression format for sparse matrices. A lot of things are easier with CVS than CRS/CCS. Let's look at MatrixScalarProduct() and MatrixScalarProductInPlace().

My current study is to add more features/methods for the compressed value storage (CVS) format. CVS is a lossless compression format for sparse matrices. A lot of things are easier with CVS than CRS/CCS. Let's look at Transpose(), SetLinearIndexMode() and TransposeToNewCVS().

There is not much to find online about the compressed value storage (CVS). It seems like CRS and CCS are the most popular matrix compression formats. So here I am writing about CVS a little more. This way, you have something to find online about it.

.Net's LINQ lets developers create applications that can be 100% data source/target agnostic. Let's look at how that can work with SQL and NoSQL databases.

Regardless what some programmers may think, SQL is still the best language to express operations with sets. And, yes, I want to stress exactly that. Sets!

Now it's time to get organized. The way I did it, Mendz.Data is a separate project from Mendz.Data.MongoDB. By default, using Mendz.Data makes the project ADO.Net ready. Adding a reference to Mendz.Data.MongoDB makes the project also MongoDB ready.

Mendz.Data.MongoDB provides the types and classes that can allow developers to use MongoDB in their applications following the same concepts, designs and principles applied by Mendz.Data for ADO.Net compatible data access (like Dapper, for example).

Mendz.Data provided classes and types that allow developers to create ADO.Net compatible data contexts and model "repositories". The primary motivation behind the design is for use with Dapper , a micro-ORM library. If you've read enough about MongoDB , you should know that it is not ADO.Net compatible. Granted, what is the Mendz.Data.MongoDB namespace all about then?

I just realized that more than six years ago, As I See Tech kinda, sorta predicted BlackBerry's trouble.

This article serves as the Mendz.Graphs series ToC (Table of Contents). Consider bookmarking for a quick and easy reference.

If you can compress them, you can decompress them, right? Decompression helps to validate the compression. In this article, I'll explore how CVS, CRS and CCS can be decompressed to a two-dimensional array T[,] dense matrix.

The CVSExtensions, CRSExtensions and CCSExtensions serve as my placeholders for compressed matrix operations. This article focuses on matrix-vector multiplication.

In .Net, extension methods are fantastic ways of adding new features to types that can share the same behavior (static methods) without necessarily changing the types' source codes. Extension methods can be maintained in separate code files. IDOKSparseMatrixExtensions provides extension methods to sparse matrices that implement IDOKSparseMatrix.

When I discussed about compressed matrices , I mentioned two common compressed matrix formats, CRS and CCS, and described a third one I called CVS. These compressed matrices are supported in Mendz.Library.Matrices.

Mendz.Library.Matrices abstracted the sparse matrix via IDOKSparseMatrix and DOKSparseMatrixBase . Now it's time to create the classes DOKSparseMatrix and DOKConcurrentSparseMatrix. From these, the coordinates keyed and linear index keyed concrete classes will be created. If you've been waiting for it, note that Mendz.Graphs..Sparse matrices use CoordinatesKeyedConcurrentSparseMatrix , which is described in this article.

After much self-deliberation, I decided that the sparse matrix must be abstracted. The primary inspiration of the sparse matrix's design in Mendz.Graphs came from Wolfram where the SparseArray is shown as a collection of coordinates and their values ((0, 0) -> 1, (3, 1) -> 3, (7, 5) -> 5, ...).

I re-organized Mendz.Library and created a separate Mendz.Library.Matrices project for the growing list of matrix-specific types and classes that started popping up while working on matrix compressions. This enhancement is big!

Once upon a time, there was a problem that inspired a quest. That quest created Mendz.Graphs, which is now a .Net Core class library that grew from a simple implementation of G = (V, E) in to one that also provides features to represent a graph as a list, a dense matrix, a sparse matrix and, quite recently, a compressed matrix.

The connection matrix is a (true, false, false)-adjacency matrix, implemented in Mendz.Graphs.Representation.Matrices namespace as the ConnectionMatrix.

Hope you're enjoying the summer! A new series on Mendz.Graphs starts tomorrow. Are you ready for what's coming next?

Enjoy the summer, everyone! A new series on Mendz.Graphs starts next week. Are you ready for what's coming next? ;-)

In Mendz.Graphs, you should find that the AdjacencyMatrix, WeightedAdjacencyMatrix and GenericAdjacencyMatrix classes are coded pretty much the same way. In fact, they are essentially coded exactly alike, with only the namespaces different. Why is this so, Mendz?

Looking at Mendz.Graphs, you can clearly see how repeatable coding patterns are celebrated. Take note, I didn't say repeating codes. I said, repeatable coding patterns. Maintenance-wise, it makes a lot of difference.

Mendz.Graphs provides a set of concrete sparse matrix implementations. Compared to dense matrices, sparse matrices save on memory by using only what's needed to represent the graph.

The incidence matrix is a rectangular matrix which entries can vary depending on whether the graph is directed or undirected, and whether the incidence matrix is oriented or not. The sparse version applies the same logic used by the dense version.

Come to think of it, the degree matrix and its variations are really sparse. Implementing the degree matrix as a sparse matrix just makes absolute sense!