Tags » Design Pattern

How To : Use JavaScript: Error Handling to Build More Efficient Windows Store Apps

Believe it or not, sometimes app developers write code that doesn’t work. Or the code works but is terribly inefficient and hogs memory. Worse yet, inefficient code results in a poor UX, driving users crazy and compelling them to uninstall the app and leave bad reviews. 4,025 more words

Visual Studio 2013

Observer Pattern in Java

Motivation:

In Object Oriented Programming there are cases when certain objects need to be informed about the changes occurred in other objects. To have a good design means to decouple as much as possible and to reduce the dependencies. 1,060 more words

Java

Proxy Design Pattern

This is a kind of Structural Design pattern.

A proxy, in its most general form, is a class functioning as an interface to something else. 575 more words

C#

Microsoft Site Templates Upgraded and are now available

 

One of the main goals of the application templates is to provide a demonstration of the application building power in SharePoint and as a potential starting point for larger, more robust applications. 925 more words

Web Part

Multi-layered architecture. OFDM modulator.

In previous article I briefly describe multi-layered architecture design pattern. In this post I want to show you some code which implement multi-layered architecture.

/* Main program */
int main()
{
	/* Declare layers */

	/* Infrastructure layer */
	Cworking_Infrastructure_Layer cworking_infrastructure;

	/* Application layer */
	Cworking_Application_Layer cworking_application;

	/* Presentation layer */
	Cworking_Presentation_Layer cworking_presentation;

	/* Declare input data */
	Cworking_Matrix_Data cworking_input_data;

	/* Declare modulated data */
	Cworking_Matrix_Data cworking_modulated_data;

	/* Declare output data */
	Cworking_Matrix_Data cworking_output_data;

	/* Initialize input and output data */
	cworking_infrastructure.cworking_allocate_matrix( cworking_input_data  );
	cworking_infrastructure.cworking_allocate_matrix( cworking_modulated_data );
	cworking_infrastructure.cworking_allocate_matrix( cworking_output_data );

	/* Load and parse input file */
	cworking_infrastructure.cworking_create_random_data( cworking_input_data );

	/* Plot chart */
	printf("\n-----------------------Input frame-----------------------\n\n");
	cworking_presentation.cworking_show_data( cworking_input_data );

	/* Run application */
	cworking_application.cworking_process_OFDM_modulation( cworking_input_data, cworking_modulated_data );

	printf("\n-----------------------Modulated frame-----------------------\n\n");
	cworking_presentation.cworking_show_data( cworking_modulated_data );

	/* Run application */
	cworking_application.cworking_process_OFDM_demodulation( cworking_modulated_data, cworking_output_data );

	printf("\n-----------------------Demodulated frame-----------------------\n\n");
	cworking_presentation.cworking_show_data( cworking_output_data );

	/* Clean memory */
	cworking_infrastructure.cworking_delete_matrix( cworking_input_data  );
	cworking_infrastructure.cworking_delete_matrix( cworking_modulated_data );
	cworking_infrastructure.cworking_delete_matrix( cworking_output_data );

	return 0;
} 141 more words
Home Page

Implementation Examples On External Polymorphism

Imagine you have two different interface functions to two classes, but yet you want to generalize them without having inheritance. There are reasons for this, maybe the classes are not modifiable, or there are too many of them. 538 more words

Flyweight Pattern

This week I am reading up on the Flyweight Pattern.  The essence of this pattern is to separate the common state from the non-common one to save memory and speed of instantiating objects.   129 more words