This is a mirror of official site: http://jasper-net.blogspot.com/

Hackers' 'Zero-Day' Exploits Stay Secret For Ten Months On Average

| Wednesday, October 17, 2012
    Maybe instead of zero-day vulnerabilities, we should call them -312-day vulnerabilities. That's how long it takes, on average, for software vendors to become aware of new vulnerabilities in their software after hackers begin to exploit them, according to a study presented by Symantec at an Association of Computing Machinery conference in Raleigh, NC this week. The researchers used data collected from 11 million PCs to correlate a catalogue of zero-day attacks with malware signatures taken from those machines. Using that retrospective analysis, they found 18 attacks that represented zero-day exploits between February 2008 and March of 2010, seven of which weren't previously known to have been zero-days. And most disturbingly, they found that those attacks continued more than 10 months on average – up to 2.5 years in some cases – before the security community became aware of them. 'In fact, 60% of the zero-day vulnerabilities we identify in our study were not known before, which suggests that there are many more zero-day attacks than previously thought — perhaps more than twice as many,' the researchers write.

Read more: Slashdot
QR: Inline image 1

Posted via email from Jasper-net

Android Push Notifications using Google Cloud Messaging (GCM), PHP and MySQL

|
Overview of Google Cloud Messaging, PHP and MySQL

In this tutorial i used PHP as server side programming language and MySQL as server side database. I installed WAMP server to install php, mysql, apache for me. If you are new to connecting PHP, MySQL to android application, i suggest you go through this tutorial How to connect Android with PHP, MySQL

You can go through the official documentation if you want to know more about GCM.

The following diagram is illustrating the overview of the tutorial and the purpose of each entity involved in this tutorial.

Inline image 1

Registering with Google Cloud Messaging

1. Goto Google APIs Console page and create a new project. (If you haven’t created already otherwise it will take you to dashboard)

Read more: Android hive
QR: Inline image 2

Posted via email from Jasper-net

Developing extension packages for Visual Studio 2005/2008/2010/2012 using C# with real-life samples

|
Introduction

The following series of articles is dedicated to the development of the extension package for Visual Studio 2005/2008/2010/2012 IDEs utilizing .NET framework and C# programming language. The following topics will be covered:

basic information on creating and debugging of MSVS plug-ins and maintaining these extensibility projects for several versions of Visual Studio inside a common source code base;
overview of Automation Object Model and various Managed Package Framework (MPF) classes
extending interface of the IDE though the automation object model's API (EnvDTE) and MPF (Managed Package Framework) classes with custom menus, toolbars, windows and options pages;
utilizing Visual C++ project automation model for gathering data needed to operate an external preprocessor/compiler, such as compilation arguments and settings for different platforms and configurations;
The content of these articles is based on our experience in developing an MSVS extension package plug-in for PVS-Studio static analyzer. A more detailed in-depth references for the topics covered here are available at the end of each article through the links to MSDN library and several other external resources.

The articles will cover the extension development only for Visual Studio 2005 and later versions. This limitation reflects that PVS-Studio also supports integration to Visual Studio starting only from version 8 (Visual Studio 2005). The main reason behind this is that a new extensibility API model was introduced for Visual Studio 2005, and this new version is not backward-compatible with previous IDE APIs.

Creating and debugging Visual Studio VSPackage extension modules

There exists a number of ways to extend Microsoft Visual Studio features. On the most basic level it's possible to automate simple routine user actions using macros. An add-In plug-in module can be used for obtaining an access to environment's UI objects, such as menu commands, windows etc. Extension of IDE's internal editors is possible through MEF (Managed Extensibility Framework) components (starting with MSVS 2010). Finally, a plug-in of the Extension Package type (known as VSPackage) is best suited for integrating large independent components into Visual Studio. VSPackage allows combining the environment automation through Automation Object Model with usage of Managed Package Framework classes (such as Package). It also provides the means of extending the automation model itself by registering user-defined custom automation objects within it. Such user automation objects, in turn, will become available through the same automation model from other user-created extensibility packages, providing these packages with access to your custom components.

Read more: Codeproject
QR: Inline image 1

Posted via email from Jasper-net

Raspberry Pi runs XBMC; reliably decodes 1080p

|
Inline image 1

This is the Raspberry Pi board, an ARM based GNU-Linux computer. We’ve heard a little bit about it, but it recently garnered our attention when the machine was shown running XBMC at 1080p. That’s a lot of decoding to be done with the small package, and it’s taken care of at the hardware level.

Regular readers will know we’re fans of the XBMC project and have been looking for a small form factor that can be stuck on the back of a television. We had hoped it would be the BeagleBaord but that never really came to fruition. But this really looks like it has potential, and with a price tag of $35 (that’s for the larger 256MB RAM option) it’s a no-brainer.

Read more: Hack a day
QR: Inline image 2

Posted via email from Jasper-net

How to Get All the Windows 8 Editions on One Install Disk

| Tuesday, October 16, 2012
Inline image 1

There are a lot of different versions of Windows, but you probably didn’t know that short of the Enterprise edition, the disc or image that you own contains all versions for that architecture. Read on to see how we can use them to make a universal Windows 8 install disc.

Things You Will Need
A x86 Version of Windows 8
A x64 Version of Windows 8
A x86 Version of Windows 8 Enterprise
A x64 Version of Windows 8 Enterprise
A Windows 8 PC
Note: While we will use all the images above you don’t really need the Enterprise Edition. You could always leave out parts of the tutorial if you know what you are doing, if you are not comfortable with that and still want to follow through you could always grab the Enterprise evaluation images that are available for free to the public, on MSDN.

Getting Started
To get started you will need to Download the Windows 8 ADK from Microsoft.

Inline image 3

Once downloaded go ahead and install it, you will only need the Deployment tools so be sure to uncheck the rest of the options.

Read more: How-to geek
QR: Inline image 2

Posted via email from Jasper-net

UEFI technology: say hello to the Windows 8 bootkit!

|
In this article we are going to analyze the Unified Extensible Firmware Interface, from both a technical and security perspective. We will also take a brief look at the new Windows 8 EFI Kernel, we’ll discover many new interesting feature Microsoft implemented in it.

In the beginning it was BIOS

Basic Input and Output system (BIOS) is a term used to indicate the technology introduced with the aim to successfully power on a Personal Computer in the early 1980s. Most CPUs at that time were implemented using 8 bit or 16 bit architecture. BIOS main task is to initialize all system peripherals as well as the CPU itself. Operating systems and software used to run in the so called “16 bit real mode” mode. Memory was limited to only 640 KB. After BIOS finished its initialization steps, it released control to the first sector of the bootable hard drive, called Master Boot Record.

BIOS technology still survives today, even though this technology is almost 30 years old. This kind of technology clearly showed its limits many times (especially with hard-drive sector addressing method). We don’t want to listen and analyze all the structural limits of the BIOS here, as it’s a well described topic online.

Before the EFI introduction, every x86 Operation System (and also x86-64 ones) used to start their loading stage still in 16 bit real mode. OS boot loader (intended here as MBR code + VBR code + boot loader) has to deal with old interrupts, used  to proper initialize early stuff. Most part of the boot loader code has to be written indeed in assembly code. This makes the developing process of a boot loader an extremely hard and challenging job. The same applies to bootkit and boot viruses development.

Inline image 1

UEFI technology has been introduced with the aim to bypass all these limits. UEFI’s job is to abstract all machine hardware-dependent code and provide a full framework capable of running EFI compatible boot applications. Thus, in a theoretical way, All EFI applications can run on any platform which is powered by UEFI technology.

UEFI Implementation – A Quick Glance

Entire UEFI code reside on the motherboard’s Firmware Volume (FV) that can be stored in a flash rom. UEFI Framework is composed by a list of handles’s database and a set of protocol interfaces.

The handle database is composed by objects called handles and protocols. Handles are a collection of one or more protocols, and protocols are data structures tagged by a GUID (global unique identifier). The data structure for a protocol may be empty, may contains data field, or may contain services (function pointer), or may contains both. During UEFI initialization, the system firmware, UEFI drivers (that run in DXE phase), and even UEFI applications create handles and attach one or more protocols to the handles. Information in the handle database is global and can be accessed by any executable UEFI images. The handle database is the central repository for the objects that are maintained by the UEFI-based firmware. It is a list of UEFI handles, and each UEFI handle is identified by a unique number. A UEFI handle may represent components such Executable Images like UEFI drivers and UEFI application (for example a boot loader), devices like network controllers and UEFI services.

Read more: IT Sec
QR: Inline image 2

Posted via email from Jasper-net

How to Enable Click To Play Plugins in Google Chrome

|
Inline image 1

Have you ever opened a webpage only to have all sorts of multimedia on the page just start playing? Chrome has a hidden setting that was designed to prevent situations just like that. Read on to find out how to enable it.

Enabling Click To Play Plugins in Chrome
Click on the settings wrench and select the settings menu item.

Inline image 2

Read more: Howt-to geek
QR: Inline image 3

Posted via email from Jasper-net

MariaDB למפתחי .NET ובכלל

|
על MySQL הוותיק והפופולארי מן הסתם כולם שמעו, וחלק אפילו משתמשים או השתמשו בעבר. מי שלא - כדאי תמיד להכיר.
עם עליית הפופולאריות שלו נתקלו המשתמשים בבעיות Scaling ואחרות שהגירסא הרשמית לא תמיד ענתה עליהם, כל מיני משתמשים התחילו לפתח פאצ'ים עם שיפורי ביצועים ויכולת. זה התחיל בעיקר עם Google ועם Facebook Patch והמשיך עם הפצות בינאריות של ממש.
 
בניגוד לשאר תואמי-MySQL (למשל Percona Server) שמגיעים בגירסאות לינוקס בלבד, MariaDB מגיע גם עם MSI להתקנה פשוטה על Windows לסוגיו, וגם עם סדרה ארוכה של תיקונים שמטרתן לעבוד טוב יותר ולנצל את מלוא הכח של מערכת ההפעלה הזו.
 
בצד האפליקציה אין הבדל: ה-Connector של MySQL לסביבת NET. ולקוחות גרפיים יעבדו עם כל התואמים ללא שינוי בקוד, כשכמובן שאפשר להתחבר גם לשרתי Linux וגם לשרתי Windows.
 
נקודת המוצא היא פשוט להחליף את MySQL ב-MariaDB. עוצרים את השירות הישן, מגדירים את החדש לאותה תיקיה של הישן ומפעילים אותו.
 
כשמתקינים את MariaDB מהקופסא הוא מגיע עם קובץ הגדרות (my.ini) מוצלח בהרבה מזה של ההפצה הרשמית, ועם רשימה ארוכה של שיפורים, כשהחלק שמעניין אותנו הוא בעיקר "מתחת למכסה המנוע", שגורם לשאילתות שאנחנו מריצים פשוט לעבוד יותר מהר ועם פחות נעילות. בין השאר הכניסו שם שיפורים ל-Optimizer, שמשפרים סוגים מסויימים של שליפות במאות ואף אלפי אחוזים.
בין השאר הוכנסו השיפורים הבאים בתחום הביצועים:
 
- שיפורי ביצועים ב-Subqueries שאפשר למדוד בעשרות ומאות אחוזים (במיוחד כשיש אינדקסים נכונים), ו-devired queries.
- שיפורי ביצועים בתחום של רפליקציה (group commit).
- שיפורים בתחום I/O על Windows.
- ניהול Threadים נכון יותר ושימוש חוזר (בעיקר באפליקציות שניטרלו Connection Pooling בצד האפליקציה).
- שיפורים בטבלאות זיכרון (Heap) - הרחבה בהמשך.
או במקור
 
המשמעות על בסיס הנתונים של ערוץ 7 למשל, לאחר התאמות באינדקסים ובשליפות לסביבה החדשה הייתה כ-70% ירידה ממוצעת במדדי ה-CPU וה-I/O של המכונות, וזה בשינוי פשוט יחסית שחטמעתו ארכה פחות משבוע (אם כי כמובן, אחרי כל עדכון גירסא, צריך היה לבדוק מה השתפר ואם יש ירידה בביצועים של שליפות אחרות).

Read more: MariaDB
QR: Inline image 1

Posted via email from Jasper-net

Writing a basic Windows debugger

|
Preamble

All of us have used some kind of debugger while programming in some language. The debugger you used may be in C++, C#, Java or another language. It might be standalone like WinDbg, or inside an IDE like Visual Studio. But have you been inquisitive over how debuggers work?

Well, this article presents the hidden glory on how debuggers work. This article only covers writing debugger on Windows. Please note that here I am concerned only about the debugger and not about compilers, linkers, or debugging extensions. Thus, we'll only debug executables (like WinDbg). This article assumes a basic understanding of multithreading from the reader (read my article on multithreading).

1. How to Debug a Program?

Two steps:

Starting the process with DEBUG_ONLY_THIS_PROCESS or DEBUG_PROCESS flags.
Setting up the debugger's loop that will handle debugging events.
Before we move further, please remember:

Debugger is the process/program which debugs the other process (target-process).
Debuggee is the process being debugged, by the debugger.
Only one debugger can be attached to a debuggee. However, a debugger can debug multiple processes (in separate threads).
Only the thread that created/spawned the debuggee can debug the target-process. Thus, CreateProcess and the debugger-loop must be in the same thread.
When the debugger thread terminates, the debuggee terminates as well. The debugger process may keep running, however.
When the debugger's debugging thread is busy processing a debug event, all threads in the debuggee (target-process) stand suspended. More on this later.

A. Starting the process with the debugging flag

Use CreateProcess to start the process, specifying DEBUG_ONLY_THIS_PROCESS as the sixth parameter (dwCreationFlags). With this flag, we are asking the Windows OS to communicate this thread for all debugging events, including process creation/termination, thread creation/termination, runtime exceptions, and so on. A detailed explanation is given below. Please note that we'll be using DEBUG_ONLY_THIS_PROCESS in this article. It essentially means we want only to debug the process we are creating, and not any child process(es) that may be created by the process we create.

STARTUPINFO si; 
PROCESS_INFORMATION pi; 
ZeroMemory( &si, sizeof(si) ); 
si.cb = sizeof(si); 
ZeroMemory( &pi, sizeof(pi) );

CreateProcess ( ProcessNameToDebug, NULL, NULL, NULL, FALSE, 
                DEBUG_ONLY_THIS_PROCESS, NULL,NULL, &si, &pi );

After this statement, you would see the process in the Task Manager, but the process hasn't started yet. The newly created process is suspended. No, we don't have to call ResumeThread, but write a debugger-loop.

B. The debugger loop

The debugger-loop is the central area for debuggers! The loop runs around the WaitForDebugEvent API. This API takes two parameters: a pointer to the DEBUG_EVENT structure and the DWORD timeout parameter. For timeout, we would simply specify INFINITE. This API exists in kernel32.dll, thus we need not link to any library.

BOOL WaitForDebugEvent(DEBUG_EVENT* lpDebugEvent, DWORD dwMilliseconds);

The DEBUG_EVENT structure contains the debugging event information. It has four members: Debug event code, process-ID, thread-ID, and the event information. As soon as WaitForDebugEvent returns, we process the received debugging event, and then eventually call ContinueDebugEvent. Here is a minimal debugger-loop:

DEBUG_EVENT debug_event = {0};
for(;;)
{
    if (!WaitForDebugEvent(&debug_event, INFINITE))
        return;
    ProcessDebugEvent(&debug_event);  // User-defined function, not API
    ContinueDebugEvent(debug_event.dwProcessId,
                      debug_event.dwThreadId,
                      DBG_CONTINUE);
}

Using the ContinueDebugEvent API, we are asking the OS to continue executing the debuggee. The dwProcessId and dwThreadId specify the process and thread. These values are the same that we received form WaitForDebugEvent. The last parameter specifies if the execution should continue or not. This parameter is relevant only if the exception-event is received. We will cover this later. Until then, we'll utilize only DBG_CONTINUE (another possible value is DBG_EXCEPTION_NOT_HANDLED).

2. Handling debugging events

There are nine different major debugging events, and 20 different sub-events under the exception-event category. I will discuss them, starting from the simplest. Here is the DEBUG_EVENT structure:

struct DEBUG_EVENT
{
    DWORD dwDebugEventCode;
    DWORD dwProcessId;
    DWORD dwThreadId;
    union {
        EXCEPTION_DEBUG_INFO Exception;
        CREATE_THREAD_DEBUG_INFO CreateThread;
        CREATE_PROCESS_DEBUG_INFO CreateProcessInfo;
        EXIT_THREAD_DEBUG_INFO ExitThread;
        EXIT_PROCESS_DEBUG_INFO ExitProcess;
        LOAD_DLL_DEBUG_INFO LoadDll;
        UNLOAD_DLL_DEBUG_INFO UnloadDll;
        OUTPUT_DEBUG_STRING_INFO DebugString;
        RIP_INFO RipInfo;
    } u;
};

WaitForDebugEvent, on successful return, fills-in the values in this structure. dwDebugEventCode specifies which debugging-event has occurred. Depending on the event-code received, one of the members of the union u contains the event information, and we should only use the respective union-member. For example, if the debug event code is OUTPUT_DEBUG_STRING_EVENT, the member OUTPUT_DEBUG_STRING_INFO would be valid.

Read more: Codeproject Part 1, Part 2
QR: Inline image 1

Posted via email from Jasper-net

OS Upgrades Powered By Git

| Monday, October 15, 2012
Inline image 2

The latest Webconverger 15 release is the first Linux distribution to be automagically updatable from a Github repository. The chroot of the OS is kept natively in git's format and fuse mounted with git-fs. Webconverger fulfills the Web kiosk use case, using Firefox and competes indirectly with Google Chrome OS. Chrome OS also has an autoupdate feature, however not as powerful, unified & transparent as when simply using git.

Read more: Slashdot
Read more: Webconverger
QR: Inline image 1

Posted via email from Jasper-net

BBQTools Team Releases Their Own Unofficial CM Updater App

|
Inline image 2

The last time we brought you news about TeamBBQ it was to introduce BBQLog, an app that pulled change logs for CM ROMs. To continue on their set of tools for CM users, TeamBBQ has released a follow up application called BBQTools.

XDA Senior Member peterperfect posted about the BBQTools application on behalf of TeamBBQ. The app is similar to the CyanogenMod Updater in functionality, as it allows you to check for and download new updates of CM for your device. Some of the other features include:

Verify if you are up-to-date with your CyanogenMod release
Download the latest rom directly
pause/resume download (a first on this kind of program)
See if GApps are up-to-date and download updated ones
See changelog from Github AND gerrit (another first)
See general/kernel/radio changelog and upload them directly on the web
Have a tutorial section and a FAQ
Our team of expert answer question you ask
Access cyanogenmod statistics
Flash .zip package directly from the application
Wipe cache/dalvik from the app
Fix permissions in background
reboot into recovery
And more!

Read more: xdadevelopers
QR: Inline image 1

Posted via email from Jasper-net

Flip This App: Secondary Mobile App Market Quietly Taking Off

| Sunday, October 14, 2012
The practice of flipping is probably most familiar to the general public from reality TV shows like 'Flip This House' on A&E. The idea is to buy a house for a lowish price, fix it up a bit, and then sell it on to a buyer, hopefully at a profit. Now, the secondary market for Android and iOS apps is beginning to see the same pattern. App creators without the time or inclination to service or monetize their apps can simply sell them off for a flat, up-front sum of money. Buyers can then either tweak them as they like or not, and either attempt to monetize them themselves or re-sell the apps to still another party. 'Probably 80% of people who want to get involved in mobile either don't know how to code an app or don't know an app developer,' says the founder of one app trading site. 'So there's this massive demand, but kind of a little bit of a barrier to entry.

Read more: Slashdot
QR: Inline image 1

Posted via email from Jasper-net

What is Extensible Storage Engine and how it can be used by Windows 8 apps to persist data

|
If you start to explore Windows 8 system folders, you will quickly find a set of the same files presented in various locations:

Inline image 1

What are these files? They are generated by Extensible Storage Engine (ESE), indexed sequential access data storage technology. ESE runtime has been a part of Windows since version 2000, empowering such products as Exchange, Active Directory and Desktop Search.

Windows 8 is not an exception. ESE is used by Zune Music, Zune Video, app repository and is available as a native API for all Windows Store app developers.

How to start

While ESE APIs can be used directly, C# developers may find using of a managed wrapper called ManagedEsent more convenient. All code samples in this post use ManagedEsent.

ManagedEsent supports Windows 8 starting from version 1.8. At this moment binaries for v1.8 are not available for download and you will need to compile sources by yourself or download assembly compiled by me to start using library .

The following code samples demonstrate how to create DatabaseRepository class that allows to instantiate ESE database, put, get and delete data. The data are represented by Event class:

public class Event
{
   public Guid Id { get; set; }
   public string Description { get; set; }
   public double Price { get; set; }
   public DateTime StartTime { get; set; }
}

Database

Creation of database includes two steps: creation of ESE instance and creation of database itself. Instances can include up to six databases and provide shared transaction log for all attached databases.

Create and configure instance

private Instance _instance;
private string _instancePath;
private string _databasePath;
private const string DatabaseName = "Database";

public void CreateInstance()
{
   _instancePath = Path.Combine(ApplicationData.Current.LocalFolder.Path, DatabaseName);
   _databasePath = Path.Combine(_instancePath, "database.edb");
   _instance = new Instance(_databasePath);

   // configure instance
   _instance.Parameters.CreatePathIfNotExist = true;
   _instance.Parameters.TempDirectory = Path.Combine(_instancePath, "temp");
   _instance.Parameters.SystemDirectory = Path.Combine(_instancePath, "system");
   _instance.Parameters.LogFileDirectory = Path.Combine(_instancePath, "logs");
   _instance.Parameters.Recovery = true;
   _instance.Parameters.CircularLog = true;

   _instance.Init();
}

Create database

The following function creates database file and configures database schema to store Events.

Read more: LunarFrog
QR: Inline image 2

Posted via email from Jasper-net

ManagedEsent

|
ESENT Managed Interop

ManagedEsent provides managed access to ESENT, the embeddable database engine native to Windows. ManagedEsent uses the esent.dll that is part of Microsoft Windows so there are no extra unmanaged binaries to download and install.

Project Components
The Microsoft.Isam.Esent.Interop namespace in EsentInterop.dll provides managed access to the basic ESENT API. Use this for applications that want access to the full ESENT feature set.

The PersistentDictionary class in EsentCollections.dll provides a persistent, generic dictionary for .NET, with LINQ support. A PersistentDictionary is backed by an ESENT database and can be used to replace a standard Dictionary, HashTable, or SortedList. Use it when you want extremely simple, reliable and fast data persistence.

esedb provides both dbm and shelve modules built on top of ESENT IronPython users.

Read more: Codeplex
QR: Inline image 1

Posted via email from Jasper-net

Gay, Lesbian, Bisexual and Transgender Employees at Microsoft

|
Inline image 2

GLEAM is the gay, lesbian, bisexual, and transgender (GLBT) employee resource group at Microsoft.

Microsoft has been a pioneer in workplace diversity. It was one of the first companies in the world to offer employee benefits to same-sex domestic partners and to include sexual orientation in its corporate nondiscrimination policy. Since 1989, Microsoft has supported and sponsored gay, lesbian, bisexual, and transgender issues at Microsoft. In 1993, the employee resource group—Gay, Lesbian, Bisexual, and Transgender Employees at Microsoft (GLEAM)—was organized. GLEAM now has more than 700 members.

Read more: Microsoft
QR: Inline image 1

Posted via email from Jasper-net

Visual Studio Update Brings Windows XP Client Support

|
The delivery of Visual Studio 2012 marked the start of a more aggressive release cadence for the product line. Microsoft discussed its intent to provide more regularly scheduled updates so that VS could keep pace with the changes in the development world, and the first community technology preview (CTP) has been released to provide developers with a glimpse of the first update that is to be delivered later this year.

The changes being previewed are varied in their size and significance:

  • Build Applications targeting Windows XP
  • Support for debugging mixed managed and Native Windows Store Applications
  • Improvements for loading symbols and source
  • IntelliTrace collection for Sharepoint Applications
  • Memory Profiling for Java Script Applications
  • Shut down MSBuild processes when Visual Studio shuts down
  • The ability for the Test Explorer to group and filter unit tests
  • Enables building code maps to easily understand relationships and navigate between disparate locations (in your managed code Right click "Show on Code Map")
  • Visual Studio integration with System Center for IntelliTrace analysis of APM exception alerts
  • JavaScript Memory Analysis tool which enables developers to inspect the memory usage in their Windows Store Applications written primarily in JavaScript and be able to diagnose potential leaks
 
Foremost among the new features is the ability to target Windows XP. Users had previously requested support for WinXP and this update will provide it. This means one executable can be deployed to WinXP, Vista, Windows 7, and Windows 8 clients. Note that while this will enable the use of VS2012 tools and compiler, it does not enable support for for .NET 4.5 on WinXP. VS2012 itself still has a minimum OS requirement of Windows 7 or Server 2008 R2.

Read more: InfoQ
QR: Inline image 1

Posted via email from Jasper-net

AWS Cost Cheat Sheet

|
I get asked about Amazon Web Services pricing literally every day. I suppose it’s a factor of the job I’m in! The AWS Simple Calculator should come with a health warning for anyone who is not already an AWS expert, and the EC2 Pricing page is a resource I personally go to a lot, but it’s not a quick reference. We do a good job in CloudVertical (signup for a free trial) of helping Cloud users understand their costs but in terms of just putting together basic, high-level indicative costs for a solution – there isn’t really a simple ‘at a glance’ solution. We do TCO (total cost of ownership) models for customers all the time, and we may launch a public, automated ‘shopping cart style’ TCO and Cloud On-Ramp Calculator in the near future (hint!), but in the mean time, here’s a cheat sheet (PDF) I put together to help with basic, quick, cursory AWS pricing.

A few of the questions it aims to answer at-a-glance:
  • How much is storage?
  • How much does an instance cost for a month?
  • What instance has about 7GB of RAM?
  • What’s the difference in cost between regions?
  • How much is data transfer?
  • How many hours are in a month? How many in a year?
  • What percentage saving could I get if I bought reserved instances?

Everything is in $USD and based on the US East (Virginia) region right now. If there’s demand for it – I’ll do the same thing in EURO and YEN – based those regions and using currency conversion at the time of creation so it gives a sense of actual cash cost relevant to users in those regions. In the next version, I’d like to add:
  • Sample Deployments – 1 Web Server, 1 DB Server + expected norms for associated costs; 2 Web Servers, 4 backend Servers; Multi-AZ/Region SMALL and LARGE deployment
  • Reserved Instances – % of Annual Cost in Upfront Investment, % Hourly Discount (amortized and not), Time Period for Return on Investment.
  • Spot Instances – Average Spot Instance price per instance and % Saving.

Read more: Cloud Vertical
QR: Inline image 1

Posted via email from Jasper-net

הגדרה של Control Template בתוך Style .

|
Inline image 1

<Window.Resources>
        <Style TargetType="{x:Type ToggleButton}" >
            <Setter Property="Width" Value="30"/>
            <Setter Property="Height" Value="30"/>
            <Setter Property="Margin" Value="3"/>
            <Setter Property="Background" Value="Lavender" />
            <Setter Property="Template">
                <Setter.Value>
                    <ControlTemplate>
                        <Ellipse x:Name="elp" Fill="Lavender"/>
                        <ControlTemplate.Triggers>
                            <Trigger Property="IsMouseOver" Value="True">
                                <Setter TargetName="elp"  Property="Fill" Value="DarkBlue"/>
                            </Trigger>
                        </ControlTemplate.Triggers>
                    </ControlTemplate>
                </Setter.Value>
            </Setter>
        </Style>
    </Window.Resources>
   
   
    <Grid>
       
        <StackPanel Orientation="Horizontal" Margin="71,35,163,27">
            <ToggleButton/>
            <ToggleButton/>
            <ToggleButton/>
        </StackPanel>
    </Grid>

Read more: מילים ב WPF
QR: Inline image 2

Posted via email from Jasper-net