DEV Community: Gary Ray

Modify IIS Site Log Location With PowerShell

Gary Ray — Mon, 22 Feb 2021 07:00:00 +0000

Over the years I have inherited multiple projects and shared web servers as I have moved teams. Often these servers have been setup or configured by several different people now long gone, and many times the defaults in IIS have never been changed. That can be a problem.

Most recently I got a frantic call from a co-worker saying “all the sites on one of the production servers have quit working.” Scrambling, I logged in with Remote Desktop to check it out. Sure enough, this server (a VM actually) has a typical setup of a small OS drive partition (C:) and a much larger Data drive partition (E:). The C: partition was reporting only double digit megabytes of free space.

Every Windows box I have dealt with in the past had an environment variable set for %SystemDrive% and that has always pointed at the C: drive in my experience. So I checked the default location for IIS logs %SystemDrive%\inetpub\logs\LogFiles and found that it contained over 120 GB of log data.

Now, there are several issues that could be discussed, like monitoring so this problem was caught 30 or 40 GB earlier. Or like log storage, mining and truncation strategies. But, the immediate problem was that I have a Data drive partition that has nearly 1.5 TB of space, and I need to configure IIS to put the logs on that drive.

I manually changed one of the sites log locations using IIS, and then realized that not only do I have 41 sites on this shared server, I also have a TEST/QA server with the same structure.

Time for PowerShell.

After a couple of tests, I arrived at the following script, saved as switch-log-location.ps1.

Import-Module WebAdministration

# Set your desired root here...     
$LogPath = "E:\IIS_Logs"

foreach($site in (ls iis:\sites\*))
{
    $PathExists = Test-Path -Path $LogPath\$($site.Name)
    if(-Not $PathExists)
    {
        New-Item $LogPath\$($site.Name) -type directory
    }
    Set-ItemProperty IIS:\Sites\$($site.Name) -name logFile.directory -value "$LogPath\$($site.Name)"
}

In seconds, all of the sites will have their log location updated, and you can get started on cleaning up the cruft in the old location. Even better, the new location will have a folder name that matches the site name for every site on the shared server.

What I Learned Teaching Python To Kids

Gary Ray — Thu, 06 Jun 2019 00:54:59 +0000

Originally posted at AgileCoder.net several years ago, but with the summer kids camp season upon us I thought I would repost it.

Several years ago I volunteered at Kids Code Conference 2015 put on by Utah Geek Events. UGE puts on several free or very low cost coding and technology events every year including Utah Code Camp and Big Mountain Data. I don't know how many times they have held a kids event, but this one was huge. Neumont University in downtown Salt Lake City hosted the event and provided an excellent venue.

I had volunteered to help with the conference weeks earlier. It figured I would be able to wander around in the HTML/JavaScript or Python sessions and just help kids who were having trouble. I've spent some time teaching my own kids and one or two of their friends a little Visual Basic, or C# or Python, but I didn't think I was ready or able to teach a 3 hour workshop focused on developing a playable game. But about a little over a week before the conference one of the organizers who also happens to work for me at my main job said several instructors had dropped out and asked if I would be willing to teach one of the Python sessions.

Let me clarify something. I don't use Python at all in my job. I barely use it at home. I don't develop games. I downloaded it and started playing with it because I had heard it was a reasonably simple language and had strong support for data analysis. That said. I was told that another experienced instructor was working on the outline and sample code, and that the workshop would be loosely based on the book Hello, World! Computer Programming for Kids and Other Beginners. I had a copy, so I started working my way through it as fast as I could.

Phil, the other instructor sent me the outline and the sample files and I dived in to getting ready to teach a room full of pre-teens and teenagers how to make a game with Python and Pygame. I originally thought I would have to teach both a morning and afternoon workshop, but as it worked out we were able to combine and work together. Phil led the morning workshop since I had never taught Python and I led the afternoon session.

So, with that long introduction, here are the things I learned:

Installation and Setup are Key

In the morning session we ended up with about 30 kids. We had USB drives with sample files and installation files for Python, Pygame and Visual Studio Code (rapidly becoming my go-to cross platform code editor). Kids and parents were sent an email with links and directions for how to setup the laptops the kids would be bringing from home. But even with that, I think only two or three of the kids entered the workshop with a computer ready to go. We ended up spending nearly the entire first hour installing and configuring kids computers. The kids who got it figured out or who we helped early quickly got bored.

Lessons: Simplify. The Hello, World book's web site has a very nice integrated installer for Mac, Windows and Linux. For the Utah Code Camp sessions on Python they recommended the Anaconda distribution that was easy to install (but didn't include Pygame which is why we didn't use it). In addition to trying an integrated installer, provide better pre-conference instructions, including how to verify that everything was installed and configured as expected. And while I am not a big fan of the IDLE editor included with Python, it's installed automatically and available on each platform, so it would have been simpler to use that and avoid the extra installation/configuration steps for Visual Studio Code.

Beware the Mac, Fear Linux

Python comes pre-installed on most Apple MacBooks and is included by default with most Linux distributions. However, both the book and our curriculum were based on Python 2.7.x and most of the installations we saw were version 3.x, and none of them included Pygame. Neither Phil nor I are Mac or Linux experts, so helping the kids work through those installation problems was particularly difficult. It also presented a small challenge when we had kids copy files or access the terminal. We know the Windows shortcuts by heart, and have no problem right-clicking to view a context menu. It was hard to help the kids with those problems. We knew we would see at least a few MacBooks, but had no idea that at least a third of the kids in each class would be using one. Linux was far more rare. I think we only had one Linux user in each session.

Lessons: There are really two lessons here. First, the Mac users (or their parents) are likely to assume that if they can run Python they are ready, but won't worry about version or about Pygame. The fix here is likely the same as the first point; better installation and configuration instructions. The second is for me. I have access to an iMac and a MacBook and really should take advantage of them to prep for my next workshop like this.

Four to One is About Right

It was really fortunate that we were able to combine classes, because for the morning session that allowed us to have Phil teach, and one other volunteer and I to roam to help. It wasn't enough. I would have been in trouble with both the installation problems and the actual teaching if it had just been me with 15-16 kids. We got lucky and in both sessions had at least one parent who could help out their own child and maybe one or two kids around them.

Lessons: In the afternoon session we had a dad in the room with his own child and 3 friends, Phil and myself. Between the three of us it was still a bit of a scramble to make sure each kid had the help they wanted, or could be assisted if they were really stuck on something. I think a ratio of about 1 instructor/volunteer to 4 students is about right. If parents are around, they usually pick things up even if they aren't programmers, but can usually only help one or two kids, so there is a much higher need for volunteers for a Kids Coding Camp than an adult coding workshop.

You Will Only Cover Half of Your Outline.

We had a great outline and Phil had put together a really organized set of source files with challenges. For instance, this was part of the source file for the topic "Lists". We would introduce the topic, show some examples and demos and then turn them loose for a few minutes on the challenges:

# This is a LIST (other languages call this an ARRAY)
my_numbers = [1, 2, 3, 4, 5]

print(my_numbers)

# ----  CHALLENGE 1 ----
# Display each number on its own line.

# ----  CHALLENGE 2 ----
# Prefix each number with "Number: " and display it.

# ----  CHALLENGE 3 ----
# Add the number 6 to the end of the list

# ----  CHALLENGE 4 ----
# Display the third item in the list (the value 3).

# ----  CHALLENGE 5 ----
# Replace the literal list with a call to the range() function.

We had about 16 topics from a Hello World intro, Basic Types, Loops, Functions... to an intro to Pygame, Sprites, Animation and finally a one player Pong-like game. Neither Phil in his morning session, nor me in the afternoon session made it anywhere near the Pygame content. Fortunately in the area of Functions and Classes we built a number guessing game, so we can honestly say that the kids did learn to build a game.

Lessons: Kids are typically going to be starting completely cold, so you need to be prepared to cover very basic information. I think they had fun, learned a lot and left excited to learn programming. For a group of true novices I think the best you can hope for in three hours is to get through basic syntax, types, conditionals, loops, functions and classes. That gives you more than enough to build a text-based fortune-teller or a number guessing game. Talking with Phil after our classes I think the best format would be to do two beginner session in the morning, and then in the afternoon repeat a beginning session for those who had been in the Scratch or JavaScript sessions, and an intermediate session where you could focus on Pygame and build a more advanced game. This would have the added benefit of simplifying the setup for the beginning class because there would be less to install and configure.

If the kids aren't typing, moving or answering a question, you have lost them.

It is incredibly easy to lose a kid's attention. In the morning session the setup hassle killed us, and even after we started teaching we had a hard time keeping everyone together and figuring out who might be struggling or bored. I found when I was teaching in the afternoon that I had to use all of the tricks I have ever learned in any teaching environment to keep the kids with me. Rather than use the defined and sometimes abstract examples I tried very hard to use examples that the kids would relate to. I asked them for help building the examples. I intentionally made simple coding mistakes and asked them to help me fix them. When doing challenges I would have them raise their hands when done, or have them get up and go stand by the wall, or turn their laptop around so I could see it. This allowed me to see who was struggling and have the ones who were picking things up easy to go try to help the ones who were struggling.

Lessons: Kids are not adults. Then need different examples. They need very quick, easily digestible bits of information, and then they need to have very quick victories when doing the challenges. They need to feel like they are being successful and helpful. It's best, especially in a longer workshop, if you can figure out ways to have them stand up and move around frequently. For example, when teaching Lists/Arrays, make a physical "list" of students. Have two hold out their arms to make the brackets, and then append, delete, sort and find actual students between those two. Anything you do to keep them active and keep their attention will help you be successful.

So there you have it. When getting ready and teaching kids coding:

Simplify the setup
Be prepared for different environments if they bring their own computers
Get close to 1-to-1 and no more than 4-1 if possible
Manage expectations and cover the basics
Have kid focused examples; make them small and engaging

Good luck!

Simplified Surrogate Keys in Oracle 12c and later

Gary Ray — Wed, 05 Jun 2019 06:00:00 +0000

In my job I work primarily in the Microsoft Stack, but I have to switch DBMS back ends frequently. Unfortunately I find it hard to keep up with changes sometimes and important updates pass me by. This is one that has been available for a few years now, but no one on my mostly SQL Server focused team knew about.

Prior to Oracle 12c there was no built in support for AutoNumber or Identity columns as featured in several other RDMBS products. Instead the pattern was to create a Sequence/Trigger pair and rely on the pair to manage the values in the column.

With the 12c release, Oracle now supports two options for similar behavior. Tables can be defined with a column as NUMBER GENERATED ALWAYS AS IDENTITY to automatically generate a system linked sequence. Alternatively a table can be defined with a column with DEFAULT ON NULL [sequence].NEXTVAL.

Tables Using IDENTITY For Surrogate Keys

Creation

The command:

CREATE TABLE default_test
    ("ID" NUMBER GENERATED ALWAYS AS IDENTITY, 
    "DESCRIPTION" VARCHAR2(50 BYTE) NOT NULL ENABLE
);

Results in a table created with this SQL generated by SQL Developer:

CREATE TABLE "[owner]"."DEFAULT_TEST"
   ("ID" NUMBER GENERATED ALWAYS AS IDENTITY
            MINVALUE 1 MAXVALUE 9999999999999999999999999999
            INCREMENT BY 1 START WITH 1
            CACHE 20 NOORDER NOCYCLE  
            NOT NULL ENABLE,
   "DESCRIPTION" VARCHAR2(50 BYTE) NOT NULL ENABLE
   ) SEGMENT CREATION DEFERRED 
   PCTFREE 10 PCTUSED 40 INITRANS 1 MAXTRANS 255 
   NOCOMPRESS LOGGING
   TABLESPACE "[owner]" NO INMEMORY ;

Viewing the columns displays

COLUMN_NAME	DATA_TYPE	NULLABLE	DATA_DEFAULT
ID	NUMBER	NO	“[owner]”.”ISEQ$$_246189”.nextval

Note how rather than having the traditional trigger/sequence pair, Oracle created a system generated sequence for you. Then it sets the default value for that row to the nextval of the system generated sequence.

Deletion

If you want to delete the table, in this case the sequence is dropped at the same time.

Executing:

DROP TABLE default_test PURGE;

Removes both the table and the automatically generated sequence (and PURGE removes them from the recycle area and makes them unavailable for flashback - careful).

Additional Details

Viewing Identity Column details

You can see the list of identity columns attached to tables by executing:

SELECT table_name,
       column_name,
       sequence_name,
       generation_type,
       identity_options
FROM all_tab_identity_cols
WHERE owner = '[owner]'
ORDER BY 1, 2;

Sample result

TABLE_NAME	COLUMN_NAME	SEQUENCE_NAME	GENERATION	IDENTITY_OPTIONS
APP_CONFIG	ID	ISEQ$$_84588	ALWAYS	START WITH: 309, INCREMENT BY: 1, MAX…
APP_CONFIG_TYPES	ID	ISEQ$$_84590	ALWAYS	START WITH: 3, INCREMENT BY: 1, MAX…

IDE Support

SQLDeveloper Version 17.3.x does not appear to support creation of IDENTITY columns in the table creation dialog. Users have to edit the table creation script manually to create an Identity column.

Tables Using DEFAULT ON NULL For Surrogate Key

Behavior similar to the IDENTITY usage above can be achieved using an explicit sequence and using the Oracle 12c enhanced DEFAULT keyword.

Creation using DEFAULT ON NULL

Executing:

CREATE SEQUENCE seq_default2_test_id;

CREATE TABLE default_test2 
   ("ID" NUMBER DEFAULT ON NULL SEQ_DEFAULT2_TEST_ID.NEXTVAL,
   "DESCRIPTION" VARCHAR2(50 BYTE) NOT NULL ENABLE
);

Will create a sequence, a table, and will cause the ID field to behave like an AutoNumber or Identity field.

The SQLDeveloper IDE generated SQL for this table is:

CREATE TABLE "[owner]"."DEFAULT_TEST2"
   ( "ID" NUMBER 
            DEFAULT ON NULL "[owner]"."SEQ_DEFAULT2_TEST_ID"."NEXTVAL"
            NOT NULL ENABLE,
        "DESCRIPTION" VARCHAR2(50 BYTE) NOT NULL ENABLE
   ) SEGMENT CREATION DEFERRED
   PCTFREE 10 PCTUSED 40 INITRANS 1 MAXTRANS 255
   NOCOMPRESS LOGGING
   TABLESPACE "[owner]" NO INMEMORY ;

Note that in neither case is an explicit primary key constraint generated by default.

DEFAULT vs. DEFAULT ON NULL

If the sequence is linked using DEFAULT alone rather than DEFAULT ON NULL there are two significant differences:

The field is not automatically designated as NOT NULL
An insert that explicitly passes NULL to the ID column (as often occurs with INSERT statements generated by ORMs) will succeed and will likely cause referential integrity errors or downstream data integrity problem.

Viewing the table columns in SQLDeveloper displays:

COLUMN_NAME	DATA_TYPE	NULLABLE	DATA_DEFAULT
ID	NUMBER	NO	“[owner]”.”SEQ_DEFAULT2_TEST_ID”.”NEXTVAL”

Deleting Default Sequences

In this case the deletion of the table will not delete the sequence automatically. It is also possible to drop the sequence without dropping the table, which due to the dependency on the sequence will cause a runtime error if the insert does not include a value for the ID column.

SQL Error: ORA-02289: sequence does not exist

To drop both objects execute:

DROP SEQUENCE seq_default2_test_id;
DROP TABLE default_test2 PURGE;

Why Switch?

Documentation in the resources listed below states

Not surprisingly, [a trigger/sequence-based table] performs much worse than the others. The direct use of a sequence [using DEFAULT] and the 12c identity column give comparable results, which are typically an order of magnitude faster than using a trigger to populate the ID column. link

If you are using small tables in a situation where you do very infrequent inserts, then sticking with a trigger/sequence pair is fine and will be easily understood by developers who have worked with older Oracle versions.

If however you have any concerns about scale and load, I would recommend switching to one of the two newer techniques.

How To Choose Which Technique To Use

Use "ID" NUMBER GENERATED ALWAYS AS IDENTITY if:

You have no need to access the sequence directly (see related bullet for DEFAULT below)
You want to ignore the creation of the sequence and let the DB handle that automatically.
You don’t mind your schema being cluttered with sequences named like ISEQ$$_219376
You want the DB to automatically handle removing the sequence if you remove the table.

Use "ID" NUMBER DEFAULT ON NULL [sequence_name].nextval if:

You need access to the returned sequence value as part of a multi-step process or transaction in an API, business layer or ORM and are going to insert it manually. In this case you use a sequence that meets your organizations naming convention.
You have a strict naming convention for sequences and want to avoid the auto-generated sequence name.
You need to ensure that sequence names are identical between Dev, Test and Production schemas.
You are ok with managing the deletion or modification of both objects if one of them is dropped.

References

Testing Odd/Even Using Bitwise AND

Gary Ray — Tue, 31 Jul 2012 06:00:00 +0000

I came to the programming world by way of an Apple II, TI 99/4A, BASIC, VB/VBA and on to C#. But my academic experience is in the world of economics, not computer science. So occasionally I come across things that are really basic (I assume) which I have clearly forgotten somewhere between Apple Basic, High School Electronics, and the ensuing decades of other trivia crammed into my brain.

The Bitwise AND is the operator that left me feeling stupid today.

Many times in my career I’ve come across code to test whether a number is odd or even. Usually I have done or seen modulo division by 2 and a comparison of the remainder.

public static bool IsOdd(int i)
{
    return ((i % 2) == 1);
}

Today I came across:

public static bool IsOdd(int i)
{
    return ((i & 1) == 1);
}

I had no idea why that worked. I looked at the ms help:

Binary & operators are predefined for the integral types and bool. For integral types, & computes the bitwise AND of its operands. For bool operands, & computes the logical AND of its operands; that is, the result is true if and only if both its operands are true.

Not particularly enlightening without doing some math, so I dug a little deeper. Reviewing binary counting I made a table on a 3x5 card, assuming a 4-bit number for simplicity:

Decimal	0	1	2	3	4	5	6	7	8
Binary	`0000`	`0001`	`0010`	`0011`	`0100`	`0101`	`0110`	`0111`	`1000`

Then I started thinking about the operation, but I initially processed it in my head as a binary addition not as the proper bitwise operation:

3 + 1
	`0011`
+	`0001`
=	`0100`

But that was clearly not right, since the result is 4, and for any positive integer greater than 0 the test would fail if addition was the underlying action. I looked up a couple more definitions for bitwise AND and finally understood this:

A bitwise AND operation (a & b) returns a one in each bit position for which the corresponding bits of both a and b are positive.

The result is a logical test for each bit:

3 & 1
	`0`	`1`	`0`	`1`
	`&0`	`&0`	`&0`	`&1`
=	`0`	`0`	`0`	`1`

Since the binary representation of decimal 1 is 0001, (front padded with as many zeros as necessary to match the bit size of the number), the only way the operation ([any integer] & 1) will return 1 is if the rightmost bit is one – all odd numbers.

The following table describes the bitwise operators in C# I find myself using now.

Operator	Usage	Description
Bitwise AND	`a & b`	Returns a one in each bit position for which the corresponding bits of both a and b are ones.
Bitwise OR	`a \| b`	Returns a one in each bit position for which the corresponding bits of a OR b or both a AND b are ones.
Bitwise XOR	`a ^ b`	Returns a one in each bit position for which the corresponding bits of either a OR b but not both a AND b are ones.
Bitwise NOT	`!a`	Inverts each bit of a.

For more on how Binary works, see swansontec.com/binary.html.

As an aside - I had never really thought about whether zero is even or odd. Turns out zero is even, and here’s why wikipedia.org/wiki/Parity_of_zero.