Read more: WebResources Depot
Step 1: Install VirtualBox
This one’s easy. Head over to the Downloads section on the VirtualBox site and snag the appropriate installer for your OS. Since it will be a little different for each OS, I won’t provide screenshots for each step here. In general there’s just a lot of “Next” clicking involved. Of note, the networking component of the setup process will temporarily disrupt your connection. So if you’re downloading anything else, wait until it is finished before continuing with the setup.
Once installation is completed, you’ll be greeted with a screen like this the first time you run VirtualBox:
Probably the biggest change in KDE SC 4.6 is the redesign of the Activities system which makes it easy to associate applications to activities - once you create some new activities, right clicking an window title you'll have an option to make that application part of a certain activity as you can see in the screenshot below:
To install KDE SC 4.6 in Ubuntu 10.10, open a terminal and copy/paste the following commands:
sudo add-apt-repository ppa:kubuntu-ppa/backports
sudo apt-get update
sudo apt-get install kubuntu-desktop
Once installed, log out and select KDE Plasma Workspace from the login window.
Read more: WEB UPD8
Read more: Lifehacker
Read more: SysAdmin1138 Expounds
| DbType | .NET | SQL Type |
| DateTime | System.DateTime | datetime |
| LocalDateTime | System.DateTime | datetime |
| UtcDateTime | System.DateTime | datetime |
| DateTimeOffset | System.DateTimeOffset | datetimeoffset |
| DateTime2 | System.DateTime | datetime2 |
| Date | System.DateTime | date |
| Time | System.DateTime | time |
| TimeAsTimeSpan | System.TimeSpan | time |
| TimeSpan | System.TimeSpan | bigint (int64) |
Read more: James Kovacs' Weblog
Read more: Unplggd.com
From Physorg:
Few areas of science are more controversial than cold fusion, the hypothetical near-room-temperature reaction in which two smaller nuclei join together to form a single larger nucleus while releasing large amounts of energy. In the 1980s, Stanley Pons and Martin Fleishmann claimed to have demonstrated cold fusion - which could potentially provide the world with a cheap, clean energy source - but their experiment could not be reproduced. Since then, all other claims of cold fusion have been illegitimate, and studies have shown that cold fusion is theoretically implausible, causing mainstream science to become highly speculative of the field in general.
Despite the intense skepticism, a small community of scientists is still investigating near-room-temperature fusion reactions. The latest news occurred last week, when Italian scientists Andrea Rossi and Sergio Focardi of the University of Bologna announced that they developed a cold fusion device capable of producing 12,400 W of heat power with an input of just 400 W. Last Friday, the scientists held a private invitation press conference in Bologna, attended by about 50 people, where they demonstrated what they claim is a nickel-hydrogen fusion reactor. Further, the scientists say that the reactor is well beyond the research phase; they plan to start shipping commercial devices within the next three months and start mass production by the end of 2011.
Read more: Zero Hedge
Ignoring the privacy implications for a second, as a website developer, you might like to know if your visitors are logged into GMail; you could use that information to automatically fill the email fields in your forms with "@gmail.com"... Perhaps you might want to make your Facebook "like" buttons more prominent if you can tell your visitor is logged into Facebook at the moment? Here's how I achieve this:
First of all. Lets check if you're logged into GMail right now (not including Google Apps)... (Yes, you are logged in). Now, how did I get that information? Really, really, easily... I generated a hidden image in my HTML similar to this:
<img style="display:none;"
onload="logged_in_to_gmail()"
onerror="not_logged_in_to_gmail()"
src="https://mail.google.com/mail/photos/static/AD34hIhNx1pdsCxEpo6LavSR8dYSmSi0KTM1pGxAjRio47pofmE9RH7bxPwelO8tlvpX3sbYkNfXT7HDAZJM_uf5qU2cvDJzlAWxu7-jaBPbDXAjVL8YGpI"
/>
I generated the URL in the "src" attribute by logging into my own GMail account, then going into the general settings and uploading a picture in the "My Picture" section. I then ticked the "Visible to everyone" checkbox, and right clicked the uploaded image to get the image location. Fetching the content at that URL does two different things depending on whether or not you're logged into GMail. If you are logged into GMail, it returns an image. If you're not logged into GMail, it redirects to a HTML page. This is why the img tag in my example above works. "onload" is triggered if an image is returned, but "onerror" is triggered otherwise.
I tested this technique in Firefox, Safari, Chrome, Opera and various versions of Internet Explorer and it worked in them all. I reported it to Google and they described it as "expected behaviour" and ignored it.
Read more: Mike Cardwell Online
Read more: Slashdot
Hover over the Firefox logo in the top-left of your window or press Ctrl+T, and Dash will appear. The Firefox Awesome Bar floats to the left, offering all the same functionality you find in the browser right now. It'll search your history, bookmarks, or submit your query to any search engine with the click of a favicon. The right half of your Dash is populated by your currently open tabs (in a strip along the top -- pinned tabs on the left) and frequently visited pages (shown below). Sites you visit most often will be placed in one of the four larger, central slides. As you can see from my screenshot, Dash doesn't always render thumbnails -- but this is the first release of an experimental add-on, so we were expecting a few bugs.
Read more: DownloadSquad
Adding an IP Address from the Command Line
Windows includes the “netsh” command which allows you to configure just about any aspect of your network connections. If you view the accepted parameters using “netsh /?” you will be presented with a list of commands each which have their own list of commands (and so on). For the purpose of adding IP addresses, we are interested in this string of parameters:
netsh interface ipv4 add address
Note: For Windows Server 2003/XP and earlier, “ipv4″ should be replaced with just “ip” in the netsh command.
If you view the help information, you can see the full list of accepted parameters but for the most part what you will be interested in is something like this:
netsh interface ipv4 add address “Local Area Connection” 192.168.1.2 255.255.255.0
The above command adds the IP Address 192.168.1.2 (with Subnet Mask 255.255.255.0) to the connection titled “Local Area Network”.
Adding Multiple IP Addresses at Once
When we accompany a netsh command with the FOR /L loop, we can quickly add multiple IP addresses. The syntax for the FOR /L loop looks like this:
FOR /L %variable IN (start,step,end) DO command
So we could easily add every IP address from an entire subnet using this command:
FOR /L %A IN (0,1,255) DO netsh interface ipv4 add address “Local Area Connection” 192.168.1.%A 255.255.255.0
This command takes about 20 seconds to run, where adding the same number of IP addresses manually would take significantly longer.
Read more: How-to-geek
Read more: GMail blog
It’s a new high for antipiracy theater, because you can of course still search for the terms by hitting enter, and get the same results as before, including direct links to torrent files hosted on well-known indexers. The move will accomplish two things, though: first, it will damage consumer trust of a company whose services are ostensibly objective, and second, it confirms for the hundredth time how quixotic and misguided the efforts of the MPAA et al. are in every action they take.
The actual censorship (I use the word lightly) is a joke. A leakier sieve than this was never wrought. While “Bittorrent” is blocked, “torrent” is not, and while some popular cyber lockers are on the blacklist (Rapidshare, Megaupload), others aren’t (Drop.io, Hotfile). As far as preventing piracy, the policy is worthless — incompetent. I have no doubt that this list was put together by the media companies, because Google would have done a far better job of doing it. The team responsible for executing this probably lost more time to derisive laughter than long lunches.
Read more: Techcrunch
A designer is often the best choice to extend the behavior of an associated component in design mode. While there exist other means like TypeDescriptionProvider, ITypeDescriptorFilterService or overriding the Component.Site property; a designer remains the easiest and most concise way. As most components rely on the public framework ComponentDesigner or ControlDesigner, using a derived custom designer poses no problem.
Trouble starts when the designer is marked internal for the System.Design assembly and is non trivial to reimplement by 'borrowing' code from Microsoft. Customizing a smart tag is one the features, which is nearly impossible without using a custom designer. An example of problematic hidden designers are ToolStrip / ToolStripItem components, with their lot of interdepending internal classes enhancing our IDE experience.
I propose the simple idea of using the internal default designer, by encapsulating it in a suitable ComponentDesigner or ControlDesigner and delegating member calls to the internal designer. This article highlights some not too obvious issues involved to make it work.The demo project uses a ContextMenuStrip and a TreeView control without any added real functionality as proof of concept.
Custom Designer Skeleton
The framework ContextMenuStrip is a Control, yet it's associated ToolStripDropDownDesigner derives from the ComponentDesigner. So our custom designer will too:
internal abstract class ToolStripDropDownDesigner : ComponentDesigner
{
protected ComponentDesigner defaultDesigner;
public override void Initialize(IComponent component)
{
// internal class ToolStripDropDownDesigner : ComponentDesigner
// Name: System.Windows.Forms.Design.ToolStripDropDownDesigner ,
// Assembly: System.Design, Version=4.0.0.0
Type tDesigner = Type.GetType
("System.Windows.Forms.Design.ToolStripDropDownDesigner, System.Design");
defaultDesigner = (ComponentDesigner)Activator.CreateInstance
(tDesigner, BindingFlags.Instance | BindingFlags.Public, null, null, null);
defaultDesigner.Initialize(component);
base.Initialize(component);
}
public override void InitializeNewComponent(IDictionary defaultValues)
{
base.InitializeNewComponent(defaultValues);
defaultDesigner.InitializeNewComponent(defaultValues);
}
protected override void Dispose(bool disposing)
{
if (disposing)
{
if (defaultDesigner != null)
{
defaultDesigner.Dispose();
}
}
base.Dispose(disposing);
}
}
Designer Properties
A designer may expose design time only properties, adding new ones or ones that shadow existing control properties.These can be marked private, as design time environment uses Reflection to read and set values. Now our custom designer was specified as the principal designer by the DesignerAttribute and our designer instead of the default designer will be queried for properties. Does this mean we have to reimplement all designer properties on our custom designer and fidget with Reflection to delegate all calls?
Luckily inserting a single line will save us from the trouble:
public override void Initialize(IComponent component)
{
...
// use Designer properties of nested designer ( do before base.Initialize ! )
TypeDescriptor.CreateAssociation(component, defaultDesigner);
defaultDesigner.Initialize(component);
base.Initialize(component);
}
Quoted from MSDN:
"The CreateAssociation method creates an association between a primary and a secondary object. Once an association is created, a designer or other filtering mechanism can add properties that route to either object into the primary object's property set. When a property invocation is made against the primary object, the GetAssociation method will be called to resolve the actual object instance that is related to its type parameter."
For clarity: Any defined properties on our designer will be queried as well, we just created an additional target. BTW, CreateAssociation() was the missing piece, when I first failed at encapsulation some years ago.
IDesignerFilter Methods
ComponentDesigner inherits from IDesignerFilter interface and we must override its methods to delegate the calls to the default designer. As the methods are marked protected, we cast the designer to the interface, in order to access them:
protected IDesignerFilter designerFilter;
designerFilter = defaultDesigner;
ComponentDesigner's PreFilterAttributes() and PreFilterEvents() implementations are empty, and PostFilterProperties() only deals with the seldom case, that component inherits from IPersistComponentSettings. We won't bother overriding these methods.
Read more: Codeproject
Read more: MS Download
For VS2003, 2005, 2008, 2010 and framework 1.0/1, 2, 3, 3.5, 4
Language: VB, C#, Visual F# , & C++ /CLR ONLY/
Features include:
[*] - Total irreversible obfuscation [old]
[*] - code protection /through code primitive concealment method`s body/
[*] - method body decomposition (™)
[*] - Control flow obfuscation /Easy/
[*] - support dll
[*] - Native Image Generator with code cleaner in primary assembly and received image...
[*] - Framework version auto-detect /1, 2, 3, 4/
[*] - Cross-Platform /64-Bit Support/
[*] - Include: Packer NetZ
Additions:
[*] - Best support of the large assembly
[*] - command line interface [optional]
[*] - Added: MATCODE Compressor
Read more: Emicrox.net
But it wasn’t just a growth year for our products—the company grew as well. In 2010 we added more than 4,500 Googlers, primarily in engineering and sales: second only to 2007 when we added over 6,000 people to Google.
I love Google because of our people. It's inspiring to be part of the team. And that's why I am excited about 2011—because it will be our biggest hiring year in company history. We’re looking for top talent—across the board and around the globe—and we’ll hire as many smart, creative people as we can to tackle some of the toughest challenges in computer science: like building a web-based operating system from scratch, instantly searching an index of more than 100 million gigabytes and even developing cars that drive themselves. There’s something at Google for everyone—from geo, to enterprise, to video—with most of the work done in small teams, effectively working as start-ups. (The average number of software engineers on a project at Google is 3.5.) That’s why the vast majority of our people stay with us, building their careers and taking on new challenges within the company.
Read more: The Official Google Blog
The main reasons for making it Base64 encoding are as follows:
1. Base64 makes a string suitable for HTTP transfer
2. It makes it a little harder to read .
But people often get confused that this is an encrypted string. Let us try to decode the string using ViewState Decoder (A nice tool created by Fritz Onion).
Here's a table with some common Mono applications I frequently use:
Read more: Poupou's Corner of the Web
However, where the binary format can really shine is when we use its dictionaries. Essentially, a dictionary string is a string which can be identified by a small integer. So instead of having to output the whole name (for example, the name ‘Person’ would be encoded in 7 bytes – 1 for the string length and 6 for each of the letters), if this string belonged to one of the dictionaries agreed upon by the two parties (one which is encoding the XML in the binary format, the other which will read the encoded binary into XML), it would normally use 1 (or 2) bytes to be represented.
An example can show it easier. The following “.NET Binary XML” document represents the XML <Envelope></Envelope>:
40 08 45 6E 76 65 6C 6F 70 65 01
The first byte (0x40) indicates that this is a “ShortElement” record, followed by the length of the element name (0x08), followed by the UTF-8 encoding of the local name (0x45 … 0x65). Finally, the last byte (0x01) represents an end element.
If the string Envelope is part of a dictionary, however, the same document can be rewritten replacing the 9 bytes used for the element with its dictionary id. Assuming that the dictionary id of “Envelope” is 0x02, this is what the same document would be encoded:
42 02 01
The first byte was changed to indicate that this is a new type of record: a “ShortDictionaryElement”. It’s followed by the dictionary id of the string it represents.
Two dictionaries
Replacing the strings with its dictionary ids is without question a great size reduction strategy for the binary encoding.
Read more: Carlos' blog
Well there are tips to be found on the internet. Some say that recompressing the XAP file with something like WinRAR on its "best" compression setting will help. But that was in the Visual Studio 2008 / Silverlight 2 days. Now if you're building a Silverlight 4 app in Visual Studio 2010 it's already going to be compressed about as heavily as is possible.
So I'm going to talk about other effective techniques that will help you today.
Tips
1.) Reduce XAP size by using application library caching (not available for out-of-browser applications). Check this option in Visual Studio 2010 and when your project is built there will be extra files automatically generated. So you'll have to upload your XAP file and any auto-generated ZIP files to the same directory. The generated ZIP files contain any external assemblies that your XAP require. Behind the scenes this relationship is automatically maintained with the AppManifest. This feature is pretty cool and very easy to use. You should note, however, that the whole idea behind it is caching. And so it speeds up requests from repeat visitors, but in practice it doesn't do a thing to speed up the experience for a new visitor. Read more about this feature from Microsoft.
2.) Make sure that you're including references to assemblies that you actually need and nothing more. Sometimes you'll need a reference to an assembly but you don't want it set to "Copy Local", as that adds to the XAP. Visual Studio 2010 is usually good about automatically setting "Copy Local" when appropriate. For example, System.Windows.Controls is not part of the runtime (it's a part of the SDK). Visual Studio knows this and when you add System.Windows.Controls to the project it automatically sets "Copy Local" to true. But when in doubt about an assembly reference, try setting "Copy Local" to false and see what happens. If your application builds and runs fine, then you're good.
3.) If you have a need for just one of these controls below, then download and use it rather than including the entire System.Windows.Controls assembly:
Calendar
Date Picker
Grid Splitter
Tab Control
4.) Set up content expiration in IIS. So far we've just been concentrating on the XAP file itself. It's easy to forget about server configuration.
Read more: SilverlightXAP Blog
Introduction to TPL Dataflow
TPL Dataflow (TDF) is a new .NET library for building concurrent applications. It promotes actor/agent-oriented designs through primitives for in-process message passing, dataflow, and pipelining. TDF builds upon the APIs and scheduling infrastructure provided by the Task Parallel Library (TPL) in .NET 4, and integrates with the language support for asynchrony provided by C#, Visual Basic, and F#.
Read more: Greg's Cool [Insert Clever Name] of the Day
Read more: MS Download
This tool will help to Migrates a SubVersion 6.x (SVN) repository to Team Foundation Server (TFS) 2010 replaying every action occurred in SubVersion.
StreamInsight 1.1 introduced the ability to use IEnumerable and IObservable objects as event sources and sinks. The IEnumerable case is pretty straightforward, since many data collections are already surfacing as this type. This was already covered by Colin in his blog. Creating your own IObservable event source is a little more involved but no less exciting – here is a primer:
First, let’s look at a very simple Observable data source. All it does is publish an integer in regular time periods to its registered observers. (For more information on IObservable, see http://msdn.microsoft.com/en-us/library/dd990377.aspx ).
sealed class RandomSubject : IObservable<int>, IDisposable
{
private bool _done;
private readonly List<IObserver<int>> _observers;
private readonly Random _random;
private readonly object _sync;
private readonly Timer _timer;
private readonly int _timerPeriod;
/// <summary>
/// Random observable subject. It produces an integer in regular time periods.
/// </summary>
/// <param name="timerPeriod">Timer period (in milliseconds)</param>
public RandomSubject(int timerPeriod)
{
_done = false;
_observers = new List<IObserver<int>>();
_random = new Random();
_sync = new object();
_timer = new Timer(EmitRandomValue);
_timerPeriod = timerPeriod;
Schedule();
}
public IDisposable Subscribe(IObserver<int> observer)
{
lock (_sync)
{
_observers.Add(observer);
}
return new Subscription(this, observer);
}
public void OnNext(int value)
{
lock (_sync)
Read more: Microsoft StreamInsight
In this part
I’m going to present the main building block of a debugger’s implementation on Linux – the ptrace system call. All the code in this article is developed on a 32-bit Ubuntu machine. Note that the code is very much platform specific, although porting it to other platforms shouldn’t be too difficult.
Motivation
To understand where we’re going, try to imagine what it takes for a debugger to do its work. A debugger can start some process and debug it, or attach itself to an existing process. It can single-step through the code, set breakpoints and run to them, examine variable values and stack traces. Many debuggers have advanced features such as executing expressions and calling functions in the debbugged process’s address space, and even changing the process’s code on-the-fly and watching the effects.
Although modern debuggers are complex beasts [1], it’s surprising how simple is the foundation on which they are built. Debuggers start with only a few basic services provided by the operating system and the compiler/linker, all the rest is just a simple matter of programming.
Linux debugging – ptrace
The Swiss army knife of Linux debuggers is the ptrace system call [2]. It’s a versatile and rather complex tool that allows one process to control the execution of another and to peek and poke at its innards [3]. ptrace can take a mid-sized book to explain fully, which is why I’m just going to focus on some of its practical uses in examples.
Let’s dive right in.
Stepping through the code of a process
I’m now going to develop an example of running a process in "traced" mode in which we’re going to single-step through its code – the machine code (assembly instructions) that’s executed by the CPU. I’ll show the example code in parts, explaining each, and in the end of the article you will find a link to download a complete C file that you can compile, execute and play with.
Read more: Eli Bendersky's website
Designer: Mac Funamizu
Read more: Yanko design
Read more: Invent Your Own Computer Games with Python
So, you want to learn the Python programming language but can’t find a concise and yet full-featured tutorial. This tutorial will attempt to teach you Python in 10 minutes. It’s probably not so much a tutorial as it is a cross between a tutorial and a cheatsheet, so it will just show you some basic concepts to start you off. Obviously, if you want to really learn a language you need to program in it for a while. I will assume that you are already familiar with programming and will, therefore, skip most of the non-language-specific stuff. The important keywords will be highlighted so you can easily spot them. Also, pay attention because, due to the terseness of this tutorial, some things will be introduced directly in code and only briefly commented on.
Properties
Python is strongly typed (i.e. types are enforced), dynamically, implicitly typed (i.e. you don’t have to declare variables), case sensitive (i.e. var and VAR are two different variables) and object-oriented (i.e. everything is an object).
Getting help
Help in Python is always available right in the interpreter. If you want to know how an object works, all you have to do is call help(<object>)! Also useful are dir(), which shows you all the object’s methods, and <object>.doc, which shows you its documentation string:
>>> help(5)
Help on int object:
(etc etc)
>>> dir(5)
['__abs__', '__add__', ...]
>>> abs.__doc__
'abs(number) -> number\n\nReturn the absolute value of the argument.'
Syntax
Python has no mandatory statement termination characters and blocks are specified by indentation. Indent to begin a block, dedent to end one. Statements that expect an indentation level end in a colon (:). Comments start with the pound (#) sign and are single-line, multi-line strings are used for multi-line comments. Values are assigned (in fact, objects are bound to names) with the equals sign (”=”), and equality testing is done using two equals signs (”==“). You can increment/decrement values using the += and -= operators respectively by the right-hand amount. This works on many datatypes, strings included. You can also use multiple variables on one line. For example:
>>> myvar = 3
>>> myvar += 2
>>> myvar
5
>>> myvar -= 1
>>> myvar
4
"""This is a multiline comment.
Read more: Stavros' Stuff
But of course C can’t relax. He’s holding the entire computing universe on his shoulders, after all. It’s not turtles all the way down — it’s turtles all the way down, then C. Not a lot of room for fun underneath that, is there?
Is there?
Well. Here’s the secret: C does let loose sometimes. And after being bottled up for so long, when the release finally does come, it’s pretty much an F5 of crazy.
Take for example a little thing called Duff’s Device:
send(short *to, short *from, int count)
{
int n=(count+7)/8;
switch(count%8){
case 0: do{ *to = *from++;
case 7: *to = *from++;
case 6: *to = *from++;
case 5: *to = *from++;
case 4: *to = *from++;
case 3: *to = *from++;
case 2: *to = *from++;
case 1: *to = *from++;
}while( --n>0);
}}
Huh?
If we look at the Jargon File entry, we see that the purpose of Duff’s Device is to continuously copy data into a memory-mapped video register.
Read more: Tenacious C
Git Extensions
First thing you should be getting is Git Extensions.
Visual Studio
If you’re a .NET developer, you’ll want to work from within Visual Studio. I’m sure you’ll be happy to learn that Git Extensions has a really nice Visual Studio integration as well.
The High Level Process
At a very high level, this is fairly simple:
Framework Version Registry Key
------------------------------------------------------------------------------------------
1.0 HKLM\Software\Microsoft\.NETFramework\Policy\v1.0\3705
1.1 HKLM\Software\Microsoft\NET Framework Setup\NDP\v1.1.4322\Install
2.0 HKLM\Software\Microsoft\NET Framework Setup\NDP\v2.0.50727\Install
3.0 HKLM\Software\Microsoft\NET Framework Setup\NDP\v3.0\Setup\InstallSuccess
3.5 HKLM\Software\Microsoft\NET Framework Setup\NDP\v3.5\Install
4.0 Client Profile HKLM\Software\Microsoft\NET Framework Setup\NDP\v4\Client\Install
4.0 Full Profile HKLM\Software\Microsoft\NET Framework Setup\NDP\v4\Full\Install
I also grabbed a copy of the stand-alone .NET 4 Redistributable package. To be honest, the less-than 50 meg package size is rather surprising - especially when you see the greater-than 230 meg package size for .NET 3.5!
One other requirement was to prevent the user from having to click a bunch of "Next" and "License Agreement" buttons during the .NET 4 installation. I had a hard time finding documentation for the command line options online, but running the /? option against the redistributable gave me the information I needed. I ended up using "/passive /showfinalerror /promptrestart" as the options. This puts the installer into passive mode, which still displays progress but skips all the user interaction, will display an error message window if any problems occur, and will prompt the user to restart if a restart is required.
Implementing The Bootstrapper
Remember that this is a proof of concept, only, at this point. Given that and my general lack of C++ or Delphi skills (though I was a Pascal programmer back in high school, 15 years ago), I wanted to skip past the hard part of putting together a real bootstrapper executable. So... I chose to go with Windows Script Host and VBScript.
Fortunately, the WSH / VBScript documentation on MSDN is good enough to get me rolling - I haven't done VBScript since the classic ASP days, and haven't done VB in any form since 2005! But it all came back to me and with the help of the docs, I was able to produce this script:
Dim WshShell, value
Set WshShell = WScript.CreateObject("WScript.Shell")
ON ERROR RESUME NEXT
Sub Run(ByVal sFile)
Dim shell
Set shell = CreateObject("WScript.Shell")
shell.Run sFile, 1, true
Set shell = Nothing
End Sub
value = wshShell.RegRead("HKLM\Software\Microsoft\NET Framework Setup\NDP\v4\Install")
if (Err.Number <> 0) Or (value is nothing) then
Run("dotnet\dotNetFx40_Full_x86_x64.exe /passive /showfinalerror /promptrestart")
end if
run("My.Actual.App.exe")
Yes, that's an "ON ERROR RESUME NEXT" in the 2nd line! ACK! I know... but we're limited in VBScript / WSH. The reason this is needed, is the RegRead call. If the key does not exist (and it won't, on a machine that doesn't have .NET 4 installed), an exception is thrown. We have to prevent the exception from failing the script and this is the only way I know of to do that. We then check for the presence of an error and run the .net installer if one was encountered.
Read more: LosTechies
What is an Open Redirection Attack?
Any web application that redirects to a URL that is specified via the request such as the querystring or form data can potentially be tampered with to redirect users to an external, malicious URL. This tampering is called an open redirection attack.
Whenever your application logic redirects to a specified URL, you must verify that the redirection URL hasn’t been tampered with. The login used in the default AccountController for both ASP.NET MVC 1.0 and ASP.NET MVC 2 is vulnerable to open redirection attacks. Fortunately, it is easy to update your existing applications to use the corrections from the ASP.NET MVC 3 Preview.
To understand the vulnerability, let’s look at how the login redirection works in a default ASP.NET MVC 2 Web Application project. In this application, attempting to visit a controller action that has the [Authorize] attribute will redirect unauthorized users to the /Account/LogOn view. This redirect to /Account/LogOn will include a returnUrl querystring parameter so that the user can be returned to the originally requested URL after they have successfully logged in.
In the screenshot below, we can see that an attempt to access the /Account/ChangePassword view when not logged in results in a redirect to /Account/LogOn?ReturnUrl=%2fAccount%2fChangePassword%2f.
Read more: Jon Galloway
It is the time of CES and the media is currently filled with a lot of very interesting products - but here is one that you will not see (unfortunately).
It's a PC the size of a napkin. The best part is that it is based on passive screen technology (epaper), which means that it only needs power when you change it. The result is that whatever you draw on it will stay on the screen forever (or atleast until you change it) without the need for cables or batteries.
Read more: Napkin PC
Look and Feel
This database is constantly updated with passwords from visitors like you!! If you know a password that's not listed here, please use the form to submit it. Remember, this is the worlds largest Router Password database and your help is needed to keep it that way.
Read more: Router password
Some of these websites have a community built around them, which gives fans the opportunity to interact directly with these new talents.
Here is a list of 10 free sites to discover new music.
TuneGlue
TuneGlue is straightforward and easy to use. Put in the name of a musical artist you like in the search bar and before you know it, you’ll have a whole web of musical artists that are in one way or another, similar to the band you started with.
Using TuneGlue, you start out with 6 similar artists, and can continue to explore and expand on them. In the case of some artists, you can also find added information such as a small bio and a link to their website.
Music-Map
A less flashy alternative to TuneGlue is Music-Map. While TuneGlue only initially suggests 6 similar artists, Music-Map instantly reveals all the similar artists in their database, with the most similar musicians closest to the original search term.
Music Roamer
Music Roamer adds another dimension to music map sites, by not only providing suggestions of similar artists, but also allowing you to listen to music directly on their site. The songs are powered by YouTube videos, but it should be said, in our experience, all of the tracks were live versions, and not always of very good quality. They also provide links to purchase the mp3s from Amazon.
Read more: Eternal Code
The Plan
What follows is an outline of the next eight or so SigOPS meetings this semester. We'll be posting all the critical information on these here web pages, so if you miss one (or have missed everything up to this point), no need to worry. Just catch up and come to the next meeting.
Hopefully, any SigOPS member who wants to write an operating system will have done so by the end of this excursion. Stay tuned for information and updates on our progress!
Table of Contents
0. Introduction
I. Development Environment
II. Debugging Methods
III. Applications
IV. Memory Management
V. Multitasking
VI. Interprocess Communication
VII. Hardware Interrupts and Drivers (work in progress)
VIII. Symmetric Multiprocessing (external link)
IX. References
Now without any more delay, here's our latest compilation of hacking and security tools for Linux:
* Ettercap
Ettercap is a console-based network sniffer/interceptor/logger that is capable of intercepting traffic on a network segment, capturing passwords, and conducting active eavesdropping against a number of common protocols. Ettercap supports active and passive dissection of many protocols (including ciphered ones) and provides many features for network and host analysis. Ettercap also has the ability to actively or passively find other poisoners on the LAN.
* Nikto
Nikto is a web server scanner that is known to perform comprehensive tests against web servers for multiple items, including over 3500 potentially dangerous files/CGIs, versions on over 900 servers, and version specific problems on over 250 servers. It performs generic and server type specific checks. It also captures and prints any cookies received.
* OpenSSH
OpenSSH is a Free and Open Source version of the SSH connectivity tools providing encrypted communication sessions over a computer network. It encrypts all traffic (including passwords) to effectively eliminate eavesdropping, connection hijacking, and other attacks. Additionally, OpenSSH provides secure tunneling capabilities and several authentication methods, and supports all SSH protocol versions.
Read more: TechSource
In this post I gathered top 4 Free Open Source Network Management Software that you can use as an IT Administrator in your network, Whether you run small or enterprise network, you will find those tools handy and effective in doing your monitoring work as simple as it could be.
1- SpiceWorks
Available at: www.spiceworks.com
Manage Everything IT…for Free! Spiceworks is the complete network management software, helpdesk, PC inventory tools & IT reporting solution designed to manage everything IT in small & medium businesses.
2- OpenNMS
Available at: www.opennms.org
3- OpenQRM
Available at: http://www.openqrm.com
Read more: zaHitchBlogs
Posts
All Comments
