This is my favorite DnB DJ.  The one and only 1.8.7.  

Enjoy the set.

Jordana - "May.We.Rock." - May Metalstep and Drum'n'Bass Set by Jordana on Mixcloud

~Geek

What is an enterprise system is and how can this design support testing processes?

An enterprise system is a compilation of separate but related modulated wares that are integrated with a single cohesive database, with multiple interfaces, to achieve the business purpose of an organization across multiple departments, in an effort to consolidate separate legacy systems and improve overall efficiencies. Enterprise systems are complex by nature but with the right planning and proper execution success can be reached and the benefits to an organization can be immense.

The enterprise system paradigm supports testing processes by offering a wide range of potential test cases for every aspect of an organization, effectively enabling developers and systems engineers to better the system as a whole for the entire enterprise in specific ways. The concept behind enterprise systems is integration through modulation, empowering organizations to perform any function required and change the system on demand and/or based on local need. For example, an accounting module that is functionally sound for US locations will calculate salaries differently than what is required for a European location. Currencies are different, taxes are different, pay scales are different, etc. As such, modified/localized versions of modules allow the organization to deploy localized versions of the accounting module, while still integrating data to the central database. This allows executives from any locale to gain insight into labor trends and costs across the enterprise to make more intelligent decisions on the direction of the company on a global scale. Test cases can be created to compare modules and sub-modules to see which are transferable to other locations of the organizations, and then run in tandem to determine functionality. Since enterprise systems are sold by the module, then allow for some customization on the customers part, the accounting module in general should be transferable to any locale, with some minor modifications to allow for local laws and practices, which saves the company money overall. It is far easier and less expensive to modify an existing module to allow for proper payroll calculations based on local laws, as an example, than it is to have the developer write a completely new module for each location that requires it and then figure out how to integrate that data without having to add too much to the already complex central database. This testing model applies to any aspect of an enterprise system: inventory, human resources, manufacturing, etc, but with different data sets. Having a global infrastructure also allows administrators to tap into collective resources to evaluate and gain feedback on any proposed update/upgrade. Sometimes, asking workers simple questions can eliminate the need for many costly test cases, which when performed in excess can actually result in project failure due to never really gaining momentum and being stuck in procedure or policy, as it were. Sometimes just listening to the users can be an administrators best test case, as long as they are willing to hear what is said and then make sure that the executives buy into the concept.



Have a question? Have a comment? Comment below, let's start a dialog.






~Geek

Integrating Information System Knowledge

Integrating Informations Systems Knowledge within an Organization

The first discussion question for my last class went something like this:

"What is the best approach to integrating IS knowledge domain-specific and professional core competency needs with your organization? Why is this approach better than others?"

After reading my fellow classmates responses, and pondering my own perspectives on the question, here is what I came up with as my response:

The theme I see in my classmates responses mirror my own opinions on this topic - the best approach is to evaluate the IS resource to determine its usefulness, or kind of knowledge, and apply the resource based on the needs and goals of the organization.  As information systems have evolved into the complex and interconnected platforms of the modern era, more domain specific competencies have emerged, resulting in a need for more specialization from IT professionals.  My families business has been scaled down over the past two years due to the economic downturn  however we continue to thrive because of my unique understanding of information systems and how they can help us be more efficient with less knowledge workers for our type of business.  The reason why we remain successful is because of information systems.  Having grown up watching my father and grandfather build the business to what it was after over 60 years (dozens of workers, four locations around the globe, representing more than 100 major brand names for all aspects of construction and hospitality supply), being a part of the downsize effort was sobering.  Before the downsize, our core competencies were spread among departments, much like found at any corporation, based on the level of skill and domain specific knowledge.  Since I am the systems engineer it is my responsibility to connect the dissimilar and unconnected workers to each other   Understanding the core competencies for each position, and its importance to the whole of the company, coupled with my IT experience and system prowess, I was able to create a cohesive environment of wares and solutions that not only integrated all domain-specific workers to the larger whole, but also helped refine our core competencies to what they have evolved into today.  A mostly interchangeable workforce that can be effective and efficient across all knowledge bases.  As another classmate noted, it would be unconventional to have an IT tech move into the accounting role especially within a larger organization, but in small businesses workers need to have a mix of knowledge because more is required by less.  Integrating information systems is the only way to accomplish this with any level of organization and efficiency.  Without properly planned and implemented information systems, and skilled workers to use them, most companies would fail before they get going because they could not remain competitive in the market.  Staying "lean and mean" in modern business is the only way most companies are still around after the harsh economic downturn  and the low cost of technology has enabled them to stay open, as well as pave the way for start-ups to reach a profitable state faster than ever.  The trick is to plan, plan, and plan.  Going into a information system migration/integration takes careful planning, testing, redesigning, retesting, and finally implementation and maintenance.  Trying to integrate the same without a plan almost always results in catastrophic failures.

...damn I love this shit...

Do you have any thoughts on the subject?  Or any questions on my contribution?  Post a comment, let's discuss.

~Geek

This is one of the best videos I have ever seen.  Best 5 minutes of my life.  Just watch it...you will see

~ Geek

I have decided to post some of my papers from class in hopes that my knowledge can be passed on to those of you looking to learn more about the world I am a part of.  This...is my passion ~Geek

Design Patterns

Abstract

            The purpose of this paper is to define, compare and contrast three software architecture design patterns, considering how or when they could be implemented, and why one method might be favored over another.  The Adapter, Factory Method, and Façade will be reviewed.  Before discussing these design patterns, structural patterns and creational patterns must be defined for clarity.

Structural Patterns

            Structural patterns define the make up of objects and manage access control to subsystems of objects.  In contrast to the architectural patterns that define an entire solution of subsystem, there are usually a number of structural-design patterns in a single framework (Hofstader, 2006).

Creational Patterns

            Creational patterns are concerned with the instantiation of objects.  The creational patterns focus on the composition of complex objects and the encapsulation of creational behavior (Hofstader, 2006).

Adapter

            The Adapter, a structural design pattern, converts the interface of a class into another interface clients expect ("Adapter Design Pattern In C# And Vb .net", 2012).  Functionally, the Adapter acts as the bridge for classes with incompatible interfaces to work together.  The four participants in this pattern are, the Target defines the domain-specific interface that Client uses, the Adapter which adapts the interface Adaptee to the Target interface, the Adaptee defines a existing interface that needs adapting, and the Client which collaborates with objects confirming to the Target interface.  The brilliance behind the Adapter pattern is that it can take incompatible classes from different libraries or frameworks and act as a translator between the two, morphing the data so it can be manipulated by the Client.  The Adapter design pattern could be an ideal solution when connecting legacy databases to newly created objects, such as in the aerospace industry where databases may be decades old and the data has to be accessed through a modern workstation.  The Adapter acts as the translator between the two frameworks so the Client can interact with the data and manipulate as necessary. 

Factory Method

            The Factory Method, a creational design pattern, defines an interface for creating an object, but let subclasses decide which class to instantiate.  Factory method lets a class defer instantiation to subclasses ("Factory Design Method Pattern In C# And Vb .net", 2012).    This pattern attempts to standardize the architectural model for a range of applications by creating a superclass, and delegating details to subclasses that are Client supplied, such as the case with assigning values to variables by way of user prompts ("Factory Method Design Pattern", n.d.).   According to "Factory Design Method Pattern In C# And Vb .net" (2012), there are four participating classes and/or objects participating in this pattern; the Product defines the interface of objects the factory method creates; the ConcreteProduct implements the Product interface; the Creator declares the factory method, which returns an object of type Product; and the ConcreteCreator which overrides the factory method to return an instance of a ConcreteProduct.  The Factory method can aid in design customization with minimal increase in complexity to the overall product.  Where other design patterns require new classes, the Factory Method only requires a new operation to introduce the new subclass into the superclass.  The Factory Method design pattern could be used to offer flexibility in creating documents of different classes but with the same basic properties as all documents.  The default template offered in word processing programs is an example of this superclass ideal where elements such as margins and fonts are predefined, which the user can further classify into a report or letter based on the values input into the subclass interfaces

Façade

The Façade Method, another structural design pattern, provides a unified interface to a set of interfaces in a subsystem.  Façade defines a higher-level interface that makes the subsystem easier to use ("Facade Design Pattern In C# And Vb .net", 2012).  This pattern attempts to provide a simple and uniform interface to a large subsystem of classes.  According to "Factory Design Method Pattern In C# And Vb .net" (2012), there are two participants in this pattern; the Façade knows which subsystem classes are responsible for a request and delegates client requests to the appropriate subsystem objects, and the Subsystem classes which implement subsystem functionality, handle work assigned by the Façade object, and have no knowledge of the façade and keep no reference to it.  An interface designed to access random segments of a complex subsystem, such as a relational database, could be created using the Façade Method to bring together all the details that need to be viewed in a singular interface, such as with an automobile manufacturer.  The factory floor must bring together the thousands of dissimilar components to construct a vehicle and developing a unified interface for all workers to access can make managing the production process, as well as the quality assurance process, easier because each subsystem (factory worker or robot in this case) can see what components have already been assembled to determine which subsystem is next in the manufacturing processes.  Accessing subsystems through a remote server could also lend itself to the Façade Method since there are a number of subsystems being utilized in the background that the user is unaware of.

Conclusion

            Design patterns exist to attempt to simplify the architecture process and assist developers in creating architectures that are easy to maintain or adapt.  The three methods discussed here are useful in their own way, and could all be used within the scope of a larger, more complex solution to achieve a cohesive system that can dynamically respond to users’ needs while minimizing administrative overhead and system complexity.  To say that one design method is preferred over another is a paradox because any design method could arguably be used in most situations, or they could all be used in certain situations and if implemented intelligently could result in a stable system architecture.

 References

Adapter Design Pattern in C# and VB .NET. (2012). Retrieved from http://www.dofactory.com/Patterns/PatternAdapter.aspx#inten

Facade Design Pattern in C# and VB .NET. (2012). Retrieved from http://www.dofactory.com/Patterns/PatternFacade.aspx#intent

Factory Design Method Pattern in C# and VB .NET. (2012). Retrieved from http://www.dofactory.com/Patterns/PatternFactory.aspx

Factory Method Design Pattern. (n.d.). Retrieved from http://sourcemaking.com/design_patterns/factory_method

Hofstader, J. (2006). Using Patterns to Define a Software Solution. Retrieved from http://msdn.microsoft.com/en-us/library/bb190165.aspx#sysptrn_topic2

instantiation. (n.d.). The Free On-line Dictionary of Computing. Retrieved May 28, 2012, from Dictionary.com website: http://dictionary.reference.com/browse/instantiation

...more to come...

Are throughput and capacity determining factors for effectiveness of a system more so than processor speed?

Simply yes, throughput and capacity are more a determining factor than processor speed on measuring the effectiveness of any system. The main reason is the processor is not usually the bottleneck in a system, its the I/O devices and BUS speeds that are the main culprits. This is why the focus in recent months across the industry have been the shift to using Solid State Drives (SSD) versus the hard disk drives (HDD) we all use presently. Secondary storage devices are generally the slowest I/O within a system so any improvements here trickle down to the rest of the system as a whole, making for more effective execution of processes and a more positive user experience. The actual throughput on a SSD versus a HDD is significantly higher, and access times are exponentially faster as well, which lead to faster response times and more efficient use of the processor. On the system board, the BUS speeds over the past few years have increased almost to the point that the BUS speed between the CPU and the primary storage is almost matched, which is a good thing. Once the speeds of the main memory BUS matches that of the CPU there is no latency experienced when swapping process states, which results in higher efficiency within the system, and better response to the users requests. At this point, the bottle neck goes back to the I/O devices. The issue with SSD right now is its expense, it has a much higher per byte cost than a traditional HDD, so dive capacities are lower. For example, (as of this post) a major online retailer sells a 500GB 7200rpm SATAIII HDD for $80, and on the same site a 512GB SATAIII SSD is $585. Plus, even with 6Gbps throughput, secondary storage still does not function at the same speed as the processor so again, the CPU ends up sitting idle more than it should, but less with an SSD. Modern multi-core processors can carry the general users through the next couple generations of innovation, and SSD's have already started improving those same users experienced with reduced latency and large performance gains. The next stage is to reduce costs so that SSD capacities increase while the price goes down, much like HDD has done over the past few decades.

Unless you are a systems engineer, gamer, or a hardcore Geek, most people do not consider the system throughput to be a potential bottleneck because all they hear or see are buzz words like "gigahertz", "multi-core", "terabytes", "BluRay", and "HD" or "3D" graphics. What most do not understand is that the throughput between the main memory, CPU, North & South bridges, and Video Processors should be as fast as possible and ideally match. For example, if the CPU core speed is rated at 2.0GHz, then in theory the memory clock speed should also be 2.0GHz, and the BUS pathways between the Bridges and Video processors should also be 2.0GHz, and so on. This produces an optimal operating environment at the hardware level, but is not usually the case because all hardware is made to function at different speeds with different capacities to appeal to different price point from cheap but functional, to expensive but really good. Once you bring I/O devices into the mix, the processor usually ends up in the idle state more often than while awaiting interrupts.

With SSD, durability is an important aspect. Since there are no moving parts, any shock given to the drive is less likely to cause severe data loss or even worse, drive damage. This is why our smartphones are able to be dropped from a couple to a few feet off the ground and usually survive without more than some cosmetic damage, because of solid state memory. If it had moving parts, those would surely get damaged on the first drop, even if only from inches above the ground. Longevity concerns is what made companies like OtterBox release ballistic shock resistant cases for mobile devices. People get attached to their devices, and it is more economical to spend $30-$50 to protect the expensive devices with a case like these, rather than have to deal with the hassle and expense of obtaining a new replacement at retail and migrating data.

What do you think? Am I on point here?

~Geek

What security issues must be resolved now which cannot wait for the next version of Windows® to arrive?

A recent discussion in my Operating Systems class prompted an interesting response on my part to what the main security issues afflicting Microsoft's systems are. Here's my 2 cents:

The most common threats to Microsoft systems on the consumer and business side is through Internet Explorer and Microsoft Office vulnerabilities. When reviewing this months Microsoft Security Bulletin, there are critical updates to patch various vulnerabilities across all releases of the Windows OS for Internet Explorer versions 6 through 9, and Microsoft Office version 2003 through 2010 SP1. The not-so-seen critical updates are for the .NET Framework, which supports interactive sessions with users through browser windows, are related to the Internet Explorer issues of an attacker being able to execute remote code by having a user visit a spoofed website and/or clicking on a link/banner that contains the malformed code. What I find interesting in this months report is that the majority of the notices that Microsoft put out have to do with the same vulnerability, namely the ability to allow an attacker to remotely execute code through a browser session. As many other of my classmates have mentioned in their posts this week, this is part of the evolution of operating system software in particular. Microsoft spends millions of dollars and thousands of man hours developing, and hardening, their kernels. With a user-base of Microsoft software reported at over 1 billion users world-wide, there are only so many scenarios that can be built into software testing labs making it impossible to correct every problem before the product is released to manufacture. Plus, many of these users have advanced knowledge of systems and software who can find vulnerabilities under scenarios impossible to test for under lab conditions. A lot of these users report those vulnerabilities to the development team so a patch can be created and released to the masses, others are not found out until a virus or some malware is put into the wild to exploit them. Security companies like Symantec and McAfee use intuitive software to track these attacks and inform the developers of the issues while generating their own patch, or cure as it were, to the impeding exploit. In the cases of major global attacks, Microsoft works with the security companies, and government entities, to create a cohesive solution to not only cure infected systems, but also protect unexposed systems from future exploitation.

With the great investment it takes to create a major operating system release, patching makes the best sense for providing important updates to a system, without disrupting the flow of user adoption and education on best practices. In some instances, such as when a system issue deals with deadlocked processes, a workaround could be implemented, such as adding a forced delay in processing time with processes competing for the same resource. This is why some of the Windows Updates sent out are related to changing registry values or adding a batch file to affect a process workaround while the development team evaluates whether this is an isolated or potentially wide-spread issue. If they determine that the issues can be replicated over a majority of the systems, then they will create a patch to permanently change the process and resolve the condition, otherwise they will leave the workaround in place for the limited cases that do come up under unusual scenarios.

What do you think? Am I on point, or way off base?

~Geek