How to Organize a Tweet Up

Just like organizing a birthday party, a bridal shower, a graduation party, or a wedding, plan a Tweet Up is no easy task, however if done properly could be memorable and will indeed speak lengths about your brand. So whether you are an agency representing a brand, or taking it upon yourself to manage it in house, here is what you need to know.

Pre-Tweet Up

GOAAAAAAAAAAAAAAAAAL!

OK so maybe dreams of the upcoming world cup are getting to me, but seriously, before you decide to go ahead with hosting a tweet up, consider writing down the goals of this tweet up? Are you doing it for brand awareness? Brand recognition? Empowering your ambassadors? Introducing/launching a new product?

Location! Location! Location!

Have you decided on a venue? One of the biggest mistakes is keeping that along the way. Locate your venue, and take it from there. Do you have a show room? Are you treating your guests to a restaurant? Or are you renting out a space at a hotel room or convention center? Your location will determine the size of your guest list, and pretty much what can be done during the event.

Bear in mind that your location needs to be suitable for the guests that you are inviting and to the brand that you are dealing with.

Drafting up a Guest List!

No that you know where you are hosting your event, how about you start with your guest list. Depending on how many people you’d like to invite, you should start asking yourself the following questions:

  • Is that person interested in my product?
  • Is that person an influencer that can positively speak about my product?
  • Is that person responsible for some decent quality tweets regardless of his/her number of followers?
  • Is that person a blogger who could be a brand Ambassador?

If you answered yes to any of the questions above, great, person X deserves to be on your list.

Planning The Event!

So, what will your event hold? Here are a few ideas to consider:

  • An MC to facilitate the event
  • A speaker who can speak about your brand/product
  • An experience zone where tweeps can experience your brand/product
  • Fun activities related to your brand/product
  • A video about your brand/product

The Initial Invitation!

Would you send your kid to a birthday party because they told you to go? Or will you wait for an invite or a phone call? Or let’s say a wedding? The same applies to inviting those influencers. Make it personal. Do not send a DM via Twitter, and do not send an email which they will know is just a part of a mass communication to secure as many people as possible. If you don’t know that person, ask for their contact info via DM, but give them a call. Start by saying something nice about a tweet or a photo they had shared earlier in the week, which will put you both at ease, and will simply

The Follow Up!

After you call the person to invite them do follow up via email, by sending out the invitation formally. Do not forget to include the venue, date, time, hashtag for the event, and RSVP email address. Be considerate enough to send out the invitation 10 days before the actual event, and give a week worth of notice for RSVPs in order to predict the final count of guests.

The Check List

So now that you’ve covered the major part of preparing a guest list, comes the check list of your event.

  • Will you provide a Twitter Feed that shows the event hashtag?
  • Will you provide a WiFi hotspot that your guests can connect to?
  • Will you hire a photographer to cover the event which can later be shared across your social networks, blog, company newsletter etc..
  • Will you be offering food and beverages? While food is not a must, refreshments such as juice, water, coffee, or tea are a must
  • Do you have anything and everything you need planned and under control?
  • How many team member’s will be attending the tweet up from your brand/agency? Have you assigned them roles to make this tweet up memorable?

DURING THE TWEET UP!

HELLO!

So you’ve planned it, you’ve worked hard for it. Now it’s time to handle it. Relax, don’t run around like a headless chicken, and remember, you are as human as the next person who walks in. Do your research, know your guests, and go ahead, introduce yourself, say something nice, exchange a few words, and mingle.

Embrace your guest list!

OK! So we’re all humans, and sometimes you might find someone annoying. Remember, not only do you represent a brand here, but that person made an effort to show up, and so they are worth of your time, effort, respect, and now is a good time to know them in real life away from their online personality.

Tweeting on the Day of the Event!

Once of the biggest issues I see in Tweet Ups is that a brand doesn’t tweet, instead, they rely on what everyone else has to say, mainly because they are too caught up preparing and organizing. Your community manager should be well aware that this is a big day for your brand, consider issuing out a few tweets during the event. One tweet every 15 – 20 minutes is acceptable. Your guests will be more than happy RTing your quality content, over bombarding their timelines with endless tweets trying to get the word out. Don’t forget your other social networks. Save Facebook for the evening where you can post pictures of the event after everyone has gone home, and to Instagram a few moments here and there.

Post Tweet Up

Do get in touch again!

Send an email, make a phone call, and get in touch on a one-to-one basis asking the tweeps you have invited what they thought of your product service/what they thought of the tweet up over all, and if they had any advice/opinion that they would like to share in private, what would it be?

Re-Tweet

Go ahead and RT what tweeps had to say during the event. It doesn’t have to all be in one night, because that is simply bombarding your followers, do it at different days at different time intervals for maximum exposure.

Create a Follow Up Database

When Obama won his first term presidency, he made sure to thank his supporters in a unique way. Just after midnight on the election night and before the VP was actually announced to the press and media, this text message was sent via SMS to all the supporters who have registered to his campaign website mybarackobama.com at the time: “Barack has chosen Senator Joe Biden to be our VP nominee. Watch the first Obama-Biden rally live at 3pm ET on www.barackobama.com Spread the word!”

So if the President of the US can do it, so can you. The next time you have updated news, promotions, or anything concerning your product, hit those tweeps up with an email. They will love you for breaking the news to them first before everyone else in town.

 

Have you organized a tweet-up before? Share your tips below

Content Loves Context

When producing content for your digital communities, it is important to remember that both content and context go hand in hand. Instead of creating content that is simply enjoyable, make sure to create content that is both personal and revolves around your customers lifestyles.

For example, if you are an airline, bring up your content a notch to include posts that go beyond destinations and airline ticket offers. Include places to wine and dine; unique experiences in different cities, cultural and lifestyle of the different regions. Yours online fans and followers will cherish the info, simply because one day it will come in handy, and that’s just one of the many ways you can keep your content in context. You simply broaden your horizon, while keeping everything in context.

Many people seem to forget the golden rule of social media; your content should be 80% valuable to your reader, and 20% about your product/service. Sometimes, we think a simple product cannot be that interesting, but it can. For example if you pick up a flour brand, you can easily consider pushing recipes, since flour involves a lot of baking. But those recipes can also be in context of occasions, New Year, Valentines, Mother’s Day, Father’s Day, Graduation, Eid, Ramadan, Halloween, Thanksgiving, Christmas and the list goes on and on. Ask your online readers to get involved, with submitting their own recipes, tips, and tricks.

Such content will ensure that your online experience will leverage context to make your company more appealing online.

The things that your fans learn from you, what they talk about, how they interact and connect with you – simply comes down to the best results because you’re keeping your content in context!

How brands should build trust through Social Media

Using social media for marketing your business and brand is no longer an option now a days, it’s a must! As brands are still trying to leave an everlasting print in the digital social sphere, they should remember it should be essential that they build trust with their customer via social media communities, the question is: how?

Here are a few tips:
(1) Don’t Lose Credibility

Sounds obvious, but it’s not as easy as it sounds. Don’t bombard your customers with information about your brand, and adding calls to action about purchasing or getting that product today. Take the time to share something informative, and involve your fans and customers through generic and engaging posts.

(2) Transparency

See the thing is, transparency is not an option, it is there, whether you want it or not, and as people are talking about issues associated with your brand, you need to embrace it, jump into the conversation, and see how you can fix it. In a report from eMarketer, 77% of buyers said they are more likely to buy from a company that uses social media. This is impressive, and telling of how consumers want to engage with brands.

(3) Be Responsive

If your customer has sometime to say and make the effort to reach out to you via your social media communities, respect that, and give them the same effort and appreciation by getting back to them. Address their issues, solve their problems, and handle them with care. The more you do that, the more loyalty you have, and the more likely you’d build brand ambassadors.

Remember, as humans, without trust, our relationships can never go past a certain level. The same goes for brands building relationships with consumers.

Useful Lite Effective Firewall .NET

Introduction

This goal of this article is to show how anyone can implement their own firewall using iphlpapi.dll. I have included a BUGGY and not fully functional GUI to show you the way. If you do implement a better GUI, I will be happy to replace the one I included here.

[DllImport("iphlpapi.dll", EntryPoint = "PfCreateInterface")]
        public static extern int PfCreateInterface(
                                        int dwName,
                                        PFFORWARD_ACTION inAction,
                                        PFFORWARD_ACTION outAction,
                                        bool UseLog,
                                        bool MustBeUnique,
                                        ref IntPtr ppInterface
                                        );

        [DllImport("iphlpapi.dll", EntryPoint = "PfDeleteInterface")]
        public static extern int PfDeleteInterface(
                                        IntPtr pInterface
                                        );

        [DllImport("iphlpapi.dll", EntryPoint = "PfBindInterfaceToIndex")]
        public static extern int PfBindInterfaceToIndex(
                                        IntPtr Interface_handle,
                                        int dwIndex,
                                        PFADDRESSTYPE pfatLinkType,
                                        ref int LinkIPAddress
                                        );

        [DllImport("iphlpapi.dll", EntryPoint = "PfBindInterfaceToIPAddress")]
        public static extern int PfBindInterfaceToIPAddress(
                                        IntPtr Interface_handle,
                                        PFADDRESSTYPE pfatType,
                                        ref int ip_address
                                        );

        [DllImport("iphlpapi.dll", EntryPoint = "PfUnBindInterface")]
        public static extern int PfUnBindInterface(
                                        IntPtr pInterface
                                        );

        [DllImport("iphlpapi.dll", EntryPoint = "PfAddFiltersToInterface")]
        public static extern int PfAddFiltersToInterface(
                                        IntPtr interface_handle,
                                        int cInFilters,
                                        [MarshalAsAttribute(UnmanagedType.Struct)] 
                                        ref PPF_FILTER_DESCRIPTOR pfiltIn,
                                        int cOutFilters,
                                        [MarshalAsAttribute(UnmanagedType.Struct)]
                                        ref PPF_FILTER_DESCRIPTOR pfiltOut,
                                        [MarshalAsAttribute(UnmanagedType.Struct)]
                                        ref PPF_FILTER_DESCRIPTOR pfHandle
                                        );

        [DllImport("iphlpapi.dll", EntryPoint = "PfRemoveFiltersFromInterface")]
        public static extern int PfRemoveFiltersFromInterface(
                                        IntPtr ih,
                                        int cInFilters,
                                        [MarshalAsAttribute(UnmanagedType.Struct)]
                                        ref PPF_FILTER_DESCRIPTOR pfiltIn,
                                        int cOutFilters,
                                        [MarshalAsAttribute(UnmanagedType.Struct)]
                                        ref PPF_FILTER_DESCRIPTOR pfiltOut
                                        );

        [DllImport("iphlpapi.dll", EntryPoint = "PfRemoveFilterHandles")]
        public static extern int PfRemoveFilterHandles(
                                        IntPtr interface_handle,
                                        int count_Filters,
                                        [MarshalAsAttribute(UnmanagedType.Struct)] 
                                        ref PPF_FILTER_DESCRIPTOR pvHandles
                                        );

        [DllImport("iphlpapi.dll", EntryPoint = "PfRebindFilters")]
        public static extern int PfRebindFilters(
                                        IntPtr pInterface,
                                        [MarshalAsAttribute(UnmanagedType.Struct)]
                                        ref PPF_LATEBIND_INFO pLateBindInfo
                                        );

        [DllImport("iphlpapi.dll", EntryPoint = "PPfAddGlobalFilterToInterface")]
        public static extern int PfAddGlobalFilterToInterface(
                                        IntPtr interface_handle,
                                        [MarshalAsAttribute(UnmanagedType.Struct)]
                                        ref GLOBAL_FILTER gfFilter
                                        );

        [DllImport("iphlpapi.dll", EntryPoint = "PfRemoveGlobalFilterFromInterface")]
        public static extern int PfRemoveGlobalFilterFromInterface(
                                        IntPtr interface_handle,
                                        [MarshalAsAttribute(UnmanagedType.Struct)]
                                        ref GLOBAL_FILTER gfFilter
                                        );

        [DllImport("iphlpapi.dll", EntryPoint = "SetIpTTL")]
        public static extern int SetIpTTL(uint ttl);

C# .NET RTP MJPEG Player

Introduction

This is an implementation of RTP/MJPEG protocol in C#. I wrote this code back in 2005.

Background

This code was used for Elphel network cameras, multicasting RTP/MJPEG but it should be compatible with almost all RTP/MJPEG technologies. This code was written from reading the related RFCs.

Using the Code

RtpPacket.cs

using System;
using System.Collections.Generic;
using System.Text;

namespace RTPLib
{
    public class RtpPacket
    {
        public static readonly int rtp_version = 2; /* the version of RTP supported */
        public static readonly int rtp_length = 12; /* fixed RTP packet header size */
        public int version; /* the version of RTP should be 2 */ 
        public byte padding; /* the padding flag **/
        public byte extension; /* the extension flag - if any extra headers 
				for higher protocol */
        public int csrc_count; /* the source count */
        public bool marker; /* the marker status */
        public int payload_type;    /* the type of payload  */
        public ushort sequence_no;  /* the sequence number of the RTP packet */
        public uint timestamp;  /* the timestamp of the RTP packet */
        public uint source_id;  /* the source id  of the RTP packet */
        public RtpPacket(byte[] _data)
        {
            decode(_data);
        }
        public void decode(byte[] data)
        {
            /*byte[] data = new byte[12];
            Array.Copy(_data, data, 12);*/ /* there should be no need 
					to copy the header */
            version = data[0] >> 6;
            padding = (byte)(0x1 & (data[0] >> 5));
            extension = (byte)(0x1 & (data[0] >> 4));
            csrc_count = 0x1F & (data[0]);
            marker = ((data[1] >> 7) == 1);
            payload_type = data[1] & 0x7f; /* we will assume it's 26 -> RTP/MJPEG */
            sequence_no = Utils.HostToNetworkOrderShort
			(System.BitConverter.ToUInt16(data, 2));
            timestamp = Utils.SwapUnsignedInt(System.BitConverter.ToUInt32(data, 4));
            source_id = Utils.SwapUnsignedInt(System.BitConverter.ToUInt32(data, 8));
        }
    }
}

JPEGFrame.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using System.Drawing;
using System.Runtime.InteropServices;
using System.ComponentModel;
namespace RTPLib
{
    public unsafe class JPEGFrame : IDisposable
    {
        private byte[] _buffer;
        private int _offset;
        private MemoryStream _stream_buffer;
        private bool _alreadyDisposed;
        private Image _frame_img;
        private bool _initialized;

        public int type_specific; /** 8 bits **/
        public int fragment_offset; /** 24 bits **/
        public int next_fragment_offset;
        /** 0-63 fixed q no restart markers **/
        public int jpeg_type; /** 8 bits **/
        /** 64-127 Restart Marker header appears immediately 
	following the main JPEG header **/
        public int q;   /** 8 bits **/ /** multiply by 8 **/
        /** 128-255 qtable is present and right after the 
	restart marker header if present **/
        /** 128 to 254 q is static to be read only once**/
        public int width; /** 8 bits **/ /** multiply by 8 **/
        public int height; /** 8 bits **/ /** multiply by 8 **/

        /** Restart Marker header **/
        public ushort restart_interval; /** 16 bits **/
        public ushort f; /** 1 bit **/
        public ushort l; /** 1 bit **/
        public ushort restart_count; /** 14 bits **/ /** f and l must be set to 1 
	and 0x3FFF if set reassemble the frame before decoding **/

        /** Quantization Table header **/
        /** must be present after the restart marker header if it is present**/
        public ushort mbz; /** 8 bits **/
        public ushort precision; /** 8 bits **/
        public ushort qlength; /** 16 bits **/
        public byte[] qtable; /** qtables **/
        public static int max_size = 8192 * 250;

        private byte[] _frag; /** hold the fragment offset number for conversion **/
        private ImageProcessing imgProceesor;
        private unsafe byte* buffer_ptr;

        public JPEGFrame()
        {
            //qtable = new byte[1024];
            //imgProceesor = new ImageProcessing();
            _buffer = new byte[max_size];
            unsafe
            {
                fixed (byte* buf_ptr = _buffer)
                    buffer_ptr = buf_ptr;
            }
            _frag = new byte[4];
            _initialized = false;
            _offset = 0;
        }
        public bool Decode(byte * data, int offset) //Decode(ref byte[] data, int offset)
        {
            if (_initialized == false)
            {
                type_specific = data[offset + 0];
                _frag[0] = data[offset + 3];
                _frag[1] = data[offset + 2];
                _frag[2] = data[offset + 1];
                _frag[3] = 0x0;
                fragment_offset = System.BitConverter.ToInt32(_frag, 0);
                jpeg_type = data[offset + 4];
                q = data[offset + 5];
                width = data[offset + 6];
                height = data[offset + 7];
                _frag[0] = data[offset + 8];
                _frag[1] = data[offset + 9];
                restart_interval = (ushort)(System.BitConverter.ToUInt16
					(_frag, 0) & 0x3FF);
                //restart_interval = (ushort)(System.BitConverter.ToUInt16
					(data, offset + 8) & 0x3FF);
                if (width == 0) /** elphel 333 full image size more than 
				just one byte less that < 256 **/
                    width = 256;
                byte[] tmp = new byte[1024];
                _offset = Utils.MakeTables(q, jpeg_type, height, width, tmp);
                qtable = new byte[_offset];
               
                Array.Copy(tmp, 0, _buffer, 0, _offset);
                Array.Copy(tmp, 0, qtable, 0, _offset); //not needed but 
                _initialized = true;
                tmp = null;
                /*Utils.StaticDispose();
                Utils.Dispose();*/
                GC.Collect();
            }
            else
            {
                _frag[0] = data[15]; //12 + 3
                _frag[1] = data[14]; //12 + 2
                _frag[2] = data[13]; //12 + 1]
                _frag[3] = 0x0;
                fragment_offset = System.BitConverter.ToInt32(_frag, 0);
                _frag[0] = data[offset + 8];
                _frag[1] = data[offset + 9];
                restart_interval = (ushort)(System.BitConverter.ToUInt16
					(_frag, 0) & 0x3FF);
                //restart_interval = (ushort)(System.BitConverter.ToUInt16
					(data, offset + 8) & 0x3FF);
            }

            return (next_fragment_offset == fragment_offset);
        }
        public unsafe bool Write(byte * data, 
	int size, out bool sync) //Write(ref byte[] data, int size,out bool sync)
        {
            if (Decode(data, 12))
            {
                    for (int i = 20; i < size;)
                    {
                        buffer_ptr[_offset] = data[i++];
                        ++_offset;
                        buffer_ptr[_offset] = data[i++];
                        ++_offset;
                    }
                size -= 20;
                next_fragment_offset += size;
                sync = true;
                return ((data[1] >> 7) == 1); 
            }
            /*
            if (Decode(data, 12))
            {
                size -= 20;
                Array.Copy(data, 20, buffer, _offset, size);
                next_fragment_offset += size;
                _offset += size;
                sync = true;
                return ((data[1] >> 7) == 1);
            }*/
            else
            {
                _offset = qtable.Length;
                next_fragment_offset = 0;
                sync = false;
                return false;
            }
        }
        public Image GetFrame(out int motion_level)
        {
            if (_initialized == false)
                throw new Exception();
            _stream_buffer = new MemoryStream(_buffer, 0, _offset, false);
            _frame_img = Image.FromStream(_stream_buffer, false, true);
            _offset = qtable.Length;
            motion_level = 0;
            next_fragment_offset = 0;
            _stream_buffer.Close();
            _stream_buffer.Dispose();
            _stream_buffer = null;
            return _frame_img;

            /*stream_buffer = new MemoryStream(_offset);
            stream_buffer.Write(buffer, 0, _offset); */
            //stream_buffer = new MemoryStream(10);
           /* GCHandle handle = GCHandle.Alloc(buffer, GCHandleType.Normal);
            IntPtr ptr = Marshal.UnsafeAddrOfPinnedArrayElement(buffer, 0);
            frame_img = new Bitmap(width * 8, height * 8, 
		(width * 8), System.Drawing.Imaging.PixelFormat.Format24bppRgb, ptr);
            */
             //Console.WriteLine(frame_img.PixelFormat.ToString() + 
             //" " + Image.GetPixelFormatSize(frame_img.PixelFormat) / 8);
           
            /*GC.ReRegisterForFinalize(stream_buffer);*/
            //Bitmap map = frame_img as Bitmap;    
            //imgProceesor.CompareUnsafeFaster(out motion_level, ref frame_img);
            //motion_level = imgProceesor.MotionLevel;
            //Console.WriteLine("motion " + motion_level);   
        }
        ~JPEGFrame()
        {
            Dispose(true);
           
        }
       protected virtual void Dispose(bool isDisposing)
       {
           if (_alreadyDisposed)
               return;
           // Don't dispose more than once.          
           if (isDisposing)
           {
               // TODO: free managed resources here.
               if(_frame_img != null)
                    _frame_img.Dispose();
               if(_stream_buffer != null)
                    _stream_buffer.Close();
               //stream_buffer.Dispose();
                _initialized = false;
               _frame_img = null;
               _stream_buffer = null;
               qtable = null;
               _buffer = null;
               _alreadyDisposed = true;
               
           }
           // TODO: free unmanaged resources here.
           // Set disposed flag:          
       }
       public void Dispose()
       {
           Dispose(true);
           GC.SuppressFinalize(true);
       }
        public override string ToString()
        {
            string ret = "type_specific= " + type_specific + "\r\n";
            ret += "fragment_offset= " + fragment_offset + "\r\n";
            ret += "type=" + jpeg_type + "\r\n";
            ret += "q=" + q + "\r\n";
            ret += "width=" + width + "\r\n";
            ret += "height=" + height;
            if (jpeg_type > 63)
            {
                ret += "\r\n" + "restart_interval=" + restart_interval + "\r\n";
                ret += "f=" + f + " l=" + l + "\r\n";
                ret += "restart_count=" + restart_count;
            }
            return ret;
        }
    }
}

Notes

Please understand that I wrote this code back in 2005 and I haven’t made any updates. If you think you can rearrange the code and provide comments, please let me know. I also hope for RTP/H.264 managed API implementation of existing open source projects.

Points of Interest

I am interested in creating Internet Exchange Points.shutt