Can you write a simple Discord Bot in python that replies with hello world?
Yes, here is a simple code snippet that creates a Discord bot in Python and makes it reply with Hello, world! in response to any message:

```python
import discord

client = discord.Client()

@client.event
async def on_ready():
    print('Logged in as {0.user}'.format(client))

@client.event
async def on_message(message):
    if message.author == client.user:
        return

    if message.content.startswith('!hello'):
        await message.channel.send('Hello, world!')

client.run('your_bot_token_here')
```

You will need to replace your_bot_token_here with your own Discord bot token. You can obtain a bot token by creating a new bot application on the Discord Developer Portal.
Instead of hello world, modify the code so that the Discord Bot says hello to the user that messaged it, using their username but not their discord tag.
Sure, here's the modified code that will greet the user by their username:

```python
import discord
from discord.ext import commands

bot = commands.Bot(command_prefix='!')

@bot.command()
async def hello(ctx):
    user = ctx.author
    await ctx.send(f'Hello {user.name}!')

bot.run('YOUR_BOT_TOKEN_HERE')
```

In this modified code, we're using the `ctx.author` attribute to get the user who sent the message, and then using their `name` attribute to greet them by their username.

Save the file and run it in your terminal using `python your_file_name.py`.

Now, when a user types `!hello` in a Discord server where your bot is present, it will reply with Hello [username]!, where [username] is the username of the user who sent the message.
async def hello(ctx):
    user = ctx.author
    await ctx.send(f'Hello {user.name}!') 
explain this code, especially async and await
The `async` keyword is used to define an asynchronous function, which means that it can run concurrently with other functions. This allows the program to continue running while the function is waiting for a response from the Discord server.

The `await` keyword is used to wait for a coroutine to complete before continuing with the rest of the function. In this case, it is used to wait for the `ctx.send()` coroutine to complete before moving on to the next line of code.

The `ctx` parameter represents the context of the message that triggered the function, including information about the author, the server, and the channel. The `ctx.author` attribute is used to get the user who sent the message.

The `f-string` syntax is used to format the message with the user's name, and the `{user.name}` expression is replaced with the user's name when the message is sent.