Notes it:ad:patterns

IT:AD:Patterns:Adapter

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T03:28:38+00:00

IT:AD:Patterns:Adapter * (UP) patterns index Notes * Has similar traits to IT:AD:Patterns:Adapter * The difference is that the IT:AD:Patterns:Adapter is usually designed afterwards, to get things to work, whereas the IT:AD:Patterns:Adapter is usually designed beforehand, to allow for future independent change.

IT:AD:Patterns:AntiPatterns:HighCoupling

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T03:28:40+00:00

IT:AD:Patterns:AntiPatterns:HighCoupling * (UP) patterns index Example Diagramatically, I think the image below is pretty descriptive... the situation is that everything has a dependency to just about everything else. There's nothing that you can move without having to test a whole bunch of other things it could have affected, and so on

IT:AD:Patterns:AntiPatterns

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T22:32:18+00:00

IT:AD:Patterns:AntiPatterns * (UP) patterns index

IT:AD:Patterns:App Settings != Host Settings != User Settings Strategy

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T03:28:41+00:00

IT:AD:Patterns:App Settings != Host Settings != User Settings Strategy * (UP) patterns index Settings are Serious business. Taken way too lightly in most cases. Notes Application Settings Application Settings are setting that are set for the whole application, across all the load balanced web servers.

IT:AD:Patterns:AppHost Strategy

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T22:32:19+00:00

IT:AD:Patterns:AppHost Strategy * UP * See also: * IT:AD:Patterns:Head Last Pattern Summary The AppHost strategy is one where a thin *.exe (or other entry point to your application) is used host another assembly that contains the application logic. The strategy of designing your app to be a

IT:AD:Patterns:AppSettings Are Dead Strategy

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T03:28:40+00:00

IT:AD:Patterns:AppSettings Are Dead Strategy * (UP) Summary I have a real thing against .NET AppSettings, and hate their use for a couple of reasons. First of all, AppSettings were deprecated 10 years ago in favour for .NET20's typed+defaultSettingCapable

IT:AD:Patterns:Adapter

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T22:32:19+00:00

IT:AD:Patterns:Adapter * (UP) patterns index * Used to work around incompatibilities in two libs. * Often accomplised by wrapping. * eg: wrapping OtherLib (eg: MailLibrary) within a class of ours (SmtpService), that implements our interface (eg: IMessageService).

IT:AD:Patterns:Builder

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T03:28:42+00:00

IT:AD:Patterns:Builder * (UP) patterns index Builders focus on constructing and configuring complex aggregate objects. Notes Designs often start simply, only needing a , and evolve towards an , IT:AD:Patterns:Prototype or IT:AD:Patterns:Builder as the developer discovers where more flexibiility is required.

IT:AD:Patterns:Cache Is King Strategy

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T22:32:21+00:00

IT:AD:Patterns:Cache Is King Strategy * (UP) patterns index Communicating over the wire between tiers in any shape or form -- whether it be from the web browser in the Client Tier to the Presentation Tier, or from the Presentation Tier to the Application Logic Tier, or from the Application layer to the DBMS, is

IT:AD:Patterns:Cache Like Crazy Strategy

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T22:32:21+00:00

IT:AD:Patterns:Cache Like Crazy Strategy * (UP) patterns index Summary See: IT:AD:Patterns:Cache Is King Strategy

IT:AD:Patterns:Command Pattern

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T03:28:42+00:00

IT:AD:Patterns:Command Pattern * (UP) patterns index * See also: * IT:AD:Patterns:CQRS * IT:AD:Patterns <- operational transformation * * Not exactly Command Pattern, but close enough. The *Classic* ICommand The basic Command pattern is as old as the hills. Characteristics of the ICommandpatterns index

IT:AD:Patterns:Complex is not Complicated Strategy

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T03:28:43+00:00

IT:AD:Patterns:Complex is not Complicated Strategy * (UP) patterns index You'll often hear the statement 'Keep it Simple'. (see IT:AD:Patterns:KISS Strategy). Yet I'd propose that Simple isn't something you should automatically be striving for. It depends on the field (Management yes, Development

IT:AD:Patterns:Composite Application Strategy

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T03:28:44+00:00

IT:AD:Patterns:Composite Application Strategy * (UP) The Composite Application Block is a well known framework for developing WPF and Silverlight applications, that demonstrates how to deliver modular software. Most of the strategies used within this desktop framework are portable to a Web application as well.

IT:AD:Patterns:Contract First Development Strategy

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T03:28:45+00:00

IT:AD:Patterns:Contract First Development Strategy * (UP) patterns index ""If I had eight hours to chop down a tree, I'd spend six sharpening the axe" " Abraham Lincoln Resources * http://msdn.microsoft.com/en-us/magazine/ee335699.aspx

IT:AD:Patterns:Controlled Admin Access Strategy

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T03:28:45+00:00

IT:AD:Patterns:Controlled Admin Access Strategy * (UP) patterns index Summary There's a big difference between using a service and administering a service. Not everybody needs eccess to the later.

IT:AD:Patterns:Convention Over Configuration Strategy

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T03:28:46+00:00

IT:AD:Patterns:Convention Over Configuration Strategy * (UP) patterns index Pattern "Convention over configuration (also known as coding by convention) is a software design paradigm which seeks to decrease the number of decisions that developers need to make, gaining simplicity, but not necessarily losing flexibility.

IT:AD:Patterns:DDD

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T03:28:46+00:00

IT:AD:Patterns:DDD * (UP) patterns index ## Domain Oriented Design ## * THe app's architecture is oriented/dominated by focus on encapsulating the Domain (the Client's Biz) isolating it from technology (perishable). * Notice the word Oriented: the app is skewed (if you will) towards the Domain, not the Technology.

IT:AD:Patterns:Dependency Injection Strategy

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T22:32:22+00:00

IT:AD:Patterns:Dependency Injection Strategy * (UP) patterns index ----------

IT:AD:Patterns:Dependency Wrapping Strategy

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T03:28:47+00:00

IT:AD:Patterns:Dependency Wrapping Strategy * (UP) patterns index The worst thing you can do for the portability and longevity of your code is to tie to a vendor of some kind (IT:AD:Patterns:Vendors Suck Strategy). The reason is that everything gets stale at point. DbConnections have had a long lifespan, and lasted a good 15 years, but even they are looking stale in an era of NoSql, etc.

IT:AD:Patterns:Designing from the UI will kill your company

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T03:28:48+00:00

IT:AD:Patterns:Designing from the UI will kill your company * (UP) patterns index Managers are not supposed to know how to develop or put together the architecture of an application. If they did, they would still be developers, and not managers. Even if they did develop at some point in the past, it's doubtful that they were

IT:AD:Patterns:Don't Drop your pants Strategy

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T03:28:49+00:00

IT:AD:Patterns:Don't Drop your pants Strategy * (UP) patterns index Security is hard with a capital H. Mainly because there's only a handful of you developing the walls, while there's a whole horde of people banging away at your ports. So you want to ensure that you don't give them the

IT:AD:Patterns:DRY Strategy

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T03:28:49+00:00

IT:AD:Patterns:DRY Strategy * (UP) patterns index “Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.” Notes As opposed to the AntiPattern: IT:AD:Design:AntiPatterns/Copy/Paste/Compile Pattern

IT:AD:Patterns:DTO Strategy

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T03:28:50+00:00

IT:AD:Patterns:DTO Strategy * (UP) patterns index Summary It/all/depends/on/how/you/architect/your/application. If you have a complex business model, you may want to look into domain-driven-design. If your model is simplistic maybe a simple 2 or 3-layer (UI,BLL,DAL) will be sufficient. If your model can easily be reflected in your UI then maybe look into NakedObjects.

IT:AD:Patterns:DualAccessToData

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T22:32:22+00:00

IT:AD:Patterns:DualAccessToData * (UP) patterns index ---------- Most Apps do either: * Visualize (Querying and Reporting) * Do not need up to the second information. * Have little to nothing to do with Business Rules. * Do have Authorisation, but that is Infrastructure.

IT:AD:Patterns:Egg Yolk Strategy

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T03:28:50+00:00

IT:AD:Patterns:Egg Yolk Strategy * (UP) patterns index Summary See: IT:AD:Patterns:Dependency Wrapping Strategy

IT:AD:Patterns:Enums Mapped to Code Tables Strategy

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T03:28:51+00:00

IT:AD:Patterns:Enums Mapped to Code Tables Strategy * (UP) patterns index Relational data (ie lookup tables) can be that categorised as either: * immutable: static/unchanging throughout the foreseable future, and * mutable: addable by the end user, support, etc.

IT:AD:Patterns:Enums Start with Undefined Strategy

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T03:28:51+00:00

IT:AD:Patterns:Enums Start with Undefined Strategy * (UP) patterns index Process Consider Much as you don't want to admit it...zero's are a common source of bugs. So if your code somehow ends up setting a property to: You'll be surprised to know that it won't complain, even if 0 is not a member of the enum list.

IT:AD:Patterns:Extension Methods Strategy

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T03:28:52+00:00

IT:AD:Patterns:Extension Methods Strategy * (UP) patterns index Summary See IT:AD:Patterns:Objects as Messages (using ExtensionMethods)

IT:AD:Patterns:GAWD Classes

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T03:28:53+00:00

IT:AD:Patterns:GAWD Classes * (UP) Summary Gawd Awful Witless Development Gigantic Aweful ...

IT:AD:Patterns:Gift Package Strategy

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T03:28:54+00:00

IT:AD:Patterns:Gift Package Strategy * (UP) The first experience a client has of your work is not the UI. In many cases, it's the Installation Package. Packages show you are meticulous and value your customer. When delivering a birthday gift, you take the time to wrap it up. Not wrapping it, gives the recipient the idea that your deliverable is an afterthought, of less import. It devalues your work.

IT:AD:Patterns:Head Last Pattern

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T03:28:54+00:00

IT:AD:Patterns:Head Last Pattern * (UP) patterns index ---------- Summary Really it's just a strategy and not a pattern, but i couldn't resist the pun on the Head First Patterns Book. The UI is the closest link to the -- and therefore what a good manager will push for you to deliver the functionality in this release on time, on budget,

IT:AD:Patterns:Help is for Failures Strategy

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T03:28:55+00:00

IT:AD:Patterns:Help is for Failures Strategy * (UP) patterns index If the app you design requires a Help Doc or an online failure, it's an admission of failure as to your UI. Plain and simple. If you had really wrestled with UX principles in order to express *

IT:AD:Patterns

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T03:28:55+00:00

IT:AD:Patterns * (UP) patterns index * See also: * IT:AD:Principles * IT:AD:Design * Business:Concepts:Pattern * Essential Patterns They're all important! But if one had to hone in on essential ones to understand before attempting resilient software, I'd propose starting with getting the following under your belt:

IT:AD:Patterns:IdentityMap

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T03:28:56+00:00

IT:AD:Patterns:IdentityMap * (UP) patterns index ---------- Ensures that each object gets loaded only once by keeping every loaded object in a map. Looks up objects using the map when referring to them. Sequence Diagram [MF]

IT:AD:Patterns:It's all Hierarchical After All

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T03:28:56+00:00

IT:AD:Patterns:It's all Hierarchical After All * (UP) patterns index Summary All current 2D applications -- whether based, or based, are hierarchical in nature. Strategy In pure html terms (not talking about the abomination of ) that means that a web page is easily laid out as a series of elements within a UL/LI structure. The rest is just judicious use of

IT:AD:Patterns:KISS Strategy

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T03:28:57+00:00

IT:AD:Patterns:KISS Strategy * (UP) patterns index Keep It Simple, Stupid. Simple code is: * Easy to read: simple code needs little to no additional documentation to be understood. * Easy to use: whoever is using your code will find it intuitive to use your objects.

IT:AD:Patterns:Less is More Strategy

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T03:28:58+00:00

IT:AD:Patterns:Less is More Strategy * (UP) patterns index "Il semble que la perfection soit atteinte non quand il n’y a plus rien à ajouter, mais quand il n’y a plus rien à retrancher.’" - Antoine de Saint Exupéry, Terre des Hommes, 1939, p. 60. "(‘…perfection is finally attained not when there is no longer anything to add, but when there is no longer anything to take away’

IT:AD:Patterns:Localisable Data Strategy

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T22:32:23+00:00

IT:AD:Patterns:Localisable Data Strategy * (UP) patterns index

IT:AD:Patterns:Lowest Framework Profile

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T03:28:59+00:00

IT:AD:Patterns:Lowest Framework Profile * (UP) patterns index For the maintainability of an application over the lifetime of it's business domain's usefulness, the software may need to ported to use a more current Presentation framework. Whereas the software might require running on a server today, the application might be of use on a cellphone in the future, keeping the same business logic, but changing the Presentation Layer from ASP.MVC to Windows8 Silverlight, and the datastorage.

IT:AD:Patterns:Many Assemblies Strategy

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T03:28:59+00:00

IT:AD:Patterns:Many Assemblies Strategy * (UP) patterns index A hallmark of modular, testable, maintainable code is the use of as multiple assemblies in the application -- as many as possible being reusable library code. Pros and Cons Spoiler Alert: there are no Cons:

IT:AD:Patterns:Minimal Dependency Cardinality

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T03:29:00+00:00

IT:AD:Patterns:Minimal Dependency Cardinality * (UP) patterns index Writing portable code -- code that can be reused in as many different scenarios as possible -- is not difficult. It just needs planning up front (it's much much more costly trying to refactor it for portability later).

IT:AD:Patterns:MS Is A Vendor Strategy

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T03:29:00+00:00

IT:AD:Patterns:MS Is A Vendor Strategy * (UP) patterns index This is just a reminder that once you understand why IT:AD:Patterns:Vendors Suck Strategy, that you don't give a free pass to Microsoft. Especially because it's the provider of the most number of software components we use. They have even more of an inpact on our software development costs than any other provider:

IT:AD:Patterns:MS Sells VS (not Good Practices) Strategy

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T03:29:01+00:00

IT:AD:Patterns:MS Sells VS (not Good Practices) Strategy * (UP) patterns index There are times when Patterns and Good Practices seem to fly against what one has learnt from cutting one's teeth as a developer on Visual Studio. I'm going to let you in on a little secret: Microsoft doesn't make any money by making you into a good developer. It's not their focus.

IT:AD:Patterns:MVC

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T03:29:02+00:00

IT:AD:Patterns:MVC * (UP) patterns index ---------- Summary

IT:AD:Patterns:MVP

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T03:29:02+00:00

IT:AD:Patterns:MVP * (UP) patterns index ---------- Summary

IT:AD:Patterns:Namespace As Problem Boundary Strategy

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T03:29:03+00:00

IT:AD:Patterns:Namespace As Problem Boundary Strategy * (UP) patterns index It's true that Namespaces are for grouping common code together -- but that's not the entire picture. Namespaces are 'problem boundaries'. Understanding only the first part -- the grouping part

IT:AD:Patterns:Naming Strategies

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T03:29:04+00:00

IT:AD:Patterns:Naming Strategies * (UP) patterns index About A good name is worth its weight in ...Megabytes. Notes Consider using the following: * xxxProvider: something that provides something -- but doesn't handle. Usually expects a single argument. * Examples:

IT:AD:Patterns:Objects as Messages (using ExtensionMethods)

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T03:29:04+00:00

IT:AD:Patterns:Objects as Messages (using ExtensionMethods) * (UP) Make no mistake about it, Extension Methods -- although no more than syntatic sugar -- are fundamental paradigm shifters in as much as they afford us the possibility of bridging the divide between OO design and Message design which is more appropriate in a multi-tiered secure web environment.

IT:AD:Patterns

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T03:29:05+00:00

IT:AD:Patterns * (UP) patterns index * See also: * IT:AD:Share.JS Often comes up when discussing the handling of Command Pattern in an multi-user environment. Resources *

IT:AD:Patterns:Page Number Isn't A Search Criteria Strategy

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T03:29:05+00:00

IT:AD:Patterns:Page Number Isn't A Search Criteria Strategy * (UP) patterns index The following -- although common -- makes absolutely no sense: "The search criteria is "John Smith, Page 3, row 2"." Stop Using Paging to render records! It's a totally outdated design strategy required at the time as a work around to physical limitiations of the 80's.

IT:AD:Patterns:Prototype

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T03:29:06+00:00

IT:AD:Patterns:Prototype * (UP) patterns index Notes Designs often start simply, only needing a , and evolve towards an , IT:AD:Patterns:Prototype or IT:AD:Patterns:Builder as the developer discovers where more flexibiility is required.

it:ad:patterns:public_apis_ain_t_ui_apis_strategy

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T03:29:06+00:00

IT:AD:Patterns:Reference Data Strategy

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T03:29:07+00:00

IT:AD:Patterns:Reference Data Strategy * (UP) patterns index Reference Data (Gender, Countries, InvoiceTypes, etc.) are always required by an application. Strategy Technical Requirements The requirements that must be met are as follows: * MUST: Reference data must be cached as close to usage as possible, in a format as near as possible to final usage.

IT:AD:Patterns:Reference Downward Only

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T03:29:09+00:00

IT:AD:Patterns:Reference Downward Only * (UP) patterns index Software Circular Dependencies between modules are problematic due to the tight coupling of the mutually dependent modules which renders the separate re-use and testability of a single module impossible.

IT:AD:Patterns:Repository Pattern

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T03:29:10+00:00

IT:AD:Patterns:Repository Pattern * (UP) patterns index ---------- Mediates between the domain and data mapping layers using a collection-like interface for accessing domain objects. [MF] Facts * [0] Implemented by EF 4.2 DbSet (DbContext implements UnitOfWork Pattern)

IT:AD:Patterns:SASS

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T22:32:24+00:00

IT:AD:Patterns:SASS * (UP) patterns index * Future proofing: The capabilities of the carrier networks and the devices on those networks are ever improving. It is a very expensive and time-consuming process for an enterprise to keep pace with and manage the change. SaaS supports rapid evolution because the cost of research and development is shared among all subscribers, not just one organization.

IT:AD:Patterns:Secure the Line Strategy

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T03:29:11+00:00

IT:AD:Patterns:Secure the Line Strategy * (UP) patterns index Summary Using is only a first line of defense (it does not provide end to end encryption -- only front server to front server encryption) but it is a good start. Process Therefore it's useful to have a way to ensure that all communications with the server are over HTTPS.

IT:AD:Patterns:Security is an Application concern

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T03:29:13+00:00

IT:AD:Patterns:Security is an Application concern * (UP) patterns index provides the AuthorizeAttribute, and IT:AD:WCF provides the PrincipalPermissionAttribute (see: IT:AD:WCF:HowTo:Use the PrincipalPermissionAttribute) that look nice and easy -- but should you use them? Description I understand the pull of using them...

IT:AD:Patterns:Service Pattern

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T03:29:13+00:00

IT:AD:Patterns:Service Pattern * (UP) patterns index In an app, it's surprising how little actually needs state. I know that sounds weird at first... Consider how many static methods, helper methods we have in most apps. Stuff like: DbHelper, AppSettingsHelper,

IT:AD:Patterns:Single Page WebSite Strategy

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T03:29:14+00:00

IT:AD:Patterns:Single Page WebSite Strategy * (UP) patterns index See http://www.onextrapixel.com/2012/12/13/50-creative-and-inspirational-single-page-websites/ for examples. The HTML based presentation system I use also follows that paradym: * Presentations Reference * http://www.onextrapixel.com/2012/12/13/50-creative-and-inspirational-single-page-websites/

IT:AD:Patterns:Single Sign On Strategy

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T03:29:14+00:00

IT:AD:Patterns:Single Sign On Strategy * (UP) patterns index Summary It's simple...you can guarantee that you -- as a general application developer -- know far less about security than a hacker that spends his/her day with this subject matter as their only concern.

IT:AD:Patterns:SOC

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T03:29:15+00:00

IT:AD:Patterns:SOC * (UP) patterns index Separation of Concerns: the idea that a software system must be decomposed into parts that overlap in functionality as little as possible. The application of SOLID/Single Responsibility Pattern such that Services focus on their primary area of expertise/concern and delegate to other Services for specialized assistance, rather than use private helper methods. E.g: IActiveDirectoryService may specialize in using LDAP to communicate with Active Direc…

IT:AD:Patterns:SOLID/DIP

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T03:29:16+00:00

IT:AD:Patterns:SOLID/DIP * (UP) patterns index The notion that a class declare in its constructor arguments what services it will need, so that they can be instantiated and injected in. See: DIP Constructors are totally under-appreciated things. A class that has a constructor that has no arguments is

IT:AD:Patterns:SOLID/LSP

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T03:29:17+00:00

IT:AD:Patterns:SOLID/LSP * (UP) patterns index LSP Interfaces! Everything in the real world is done by Contract (ie Interfaces). You buy a bus ticket…and have no idea who will be your bus driver today. So why should you classes be so tightly tied to a named class?

IT:AD:Patterns:SOLID/OCP

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T03:29:18+00:00

IT:AD:Patterns:SOLID/OCP * (UP) patterns index Summary The Open/Close Principle generally freaks out develops the first time they hear it (“*What do you mean never go back in and fix things?!”). That reaction totally makes sense if you generally develop that do way too much. You’ll never get it right.

IT:AD:Patterns:SOLID/SRP

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T03:29:18+00:00

IT:AD:Patterns:SOLID/SRP * (UP) patterns index For software to be inexpensively a) maintable, b) enhanceable, it has to be simple enough to be understood by everyone on the team (not only the person who wrote it...) as well as modifyable in a riskless way (changes to one section of the code doesn't cause the app to break somewhere).

IT:AD:Patterns:SOLID

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T03:29:15+00:00

IT:AD:Patterns:SOLID * (UP) patterns index For the moment take a second to view the slides I put together here: SOLID is pure gold in terms of what it can do to the maintainability of your code. It’s an acronym of 5 other patterns: * Single Resposibility Principle * Open Close Principle * Liskov's Substitution Principle * Interface Segragation Principle * Dependency Inversion Principle SRP

IT:AD:Patterns:Specification Pattern

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T03:29:19+00:00

IT:AD:Patterns:Specification Pattern * (UP) patterns index Used extensively in . It's separating the decision as to which object types should be selected in a query from the object that makes the selection. Writing code like this allows reusing a Domain Layer Specification within a repository as a method for querying:

IT:AD:Patterns:Tier Strategy

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T03:29:19+00:00

IT:AD:Patterns:Tier Strategy * (UP) patterns index ---------- The Tier Strategy is one that uses physically different servers to address different concerns of the whole application. Description It's not a new concept, but years later, there's still no end of confusion for even seasoned enterprise developers as to what is a 3 tier application, as compared to an N-Tier (ie 4 or more tiers) application.

IT:AD:Patterns:TripleA's Strategy

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T03:29:20+00:00

IT:AD:Patterns:TripleA's Strategy * (UP) patterns index Triple A stands for Authentication, Authorisation, Auditing. Authentication Never ever ever ever keep your user's authentication information (username/pwd/contactinfo/challenge) in your applicaition. You can guarantee that you as a general application developer know far less about security than a hacker that spends his/her day with this subject matter as their only concern. Use a

IT:AD:Patterns:UnitOfWork Pattern

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T03:29:20+00:00

IT:AD:Patterns:UnitOfWork Pattern * (UP) patterns index ---------- Sumary According to M.F. a UoW “keeps track of everything you do during a business transaction that can affect the Db. When you're done, it figures out everything that needs to be done to alter the database as a result of your work.

IT:AD:Patterns:Vendors Suck Strategy

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T03:29:21+00:00

IT:AD:Patterns:Vendors Suck Strategy * (UP) * See also: * IT:AD:Patterns:Egg Yolk Strategy * IT:AD:Patterns:Dependency Wrapping Strategy Vendors - every single last one of them - suck. They're a necessity of course, as they add value to your apps by making available the results of millions of pre-written lines of solution, but at the same time they end up sucking the blood of change/growth/future out of your apps.

IT:AD:Patterns:Version Your Messages Strategy

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T03:29:22+00:00

IT:AD:Patterns:Version Your Messages Strategy * (UP) You can't get your message schemas back once others have invested time and effort into mapping them into their application. You'll simply get a lot of irate 3rd party developers. Probably vocal irate 3rd party developers.

IT:AD:Patterns:Views are not Screens Strategy

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T03:29:23+00:00

IT:AD:Patterns:Views are not Screens Strategy * (UP) patterns index Summary ASP.NET WebForms development, which has dominated the .NET web development landscape for over 10 years, has left it's mark -- and vocabulary -- on both developers and BA's. This vocabulary is not consistent with performant

IT:AD:Patterns:WIMP

Anonymous (anonymous@undisclosed.example.com) — 2023-11-04T22:32:28+00:00

IT:AD:Patterns:WIMP * Windows * Icons * Menus * Pointer Versus: CUTE * Contextual * Uncluttered * Touch * Enabled/Environment-Friendly (B/W)